#include "nsCOMPtr.h"

 // Inspired by

 // toolkit/components/extensions/storage/ExtensionStorageComponents.h.

 // Implemented in Rust

 namespace torproject {

   nsresult rv = NewTorServiceImpl(getter_AddRefs(service));

   if (NS_WARN_IF(NS_FAILED(rv))) {

     return nullptr;

     {

         'cid': '{2537313c-e120-408c-a2f6-86e6e1bdf899}',

         'contract_ids': ['@torproject.org/tor-service;1'],

         'constructor': 'torproject::NewTorService',

         'headers': ['torproject/TorService.h'],

         'js_name': 'tor',

 # file, You can obtain one at http://mozilla.org/MPL/2.0/.

 XPIDL_MODULE = "tor"

 XPCOM_MANIFESTS += [

     "components.conf",

 ]

 #include "nsIFile.idl"

 [scriptable, uuid(4b250614-968a-412f-9191-9ffd9d4bd001)]

   void onAsyncMessage(in ACString message);

 };

 [scriptable, uuid(1389d157-4695-43a2-a7d8-538aaa350766)]

   void onMessage(in ACString message);

   void onError(in ACString error);

 };

 // TODO: Remove once we have a provider.

 [scriptable, uuid(f56d710e-5650-4b8c-8d31-279f360003ee)]

   void close();

 };

 [scriptable, uuid(2537313c-e120-408c-a2f6-86e6e1bdf899)]

   // For development purposes...

 };

 // <http://opensource.org/licenses/MIT>, at your option. This file may not be

 // copied, modified, or distributed except according to those terms.

 use std::{

     cell::Cell,

     rc::{Rc, Weak},

         }

     }

     fn send_command(

         self: &Rc<Self>,

         handler: Box<dyn FnOnce(Result<Reply, ControlPortError>)>,

     ) {

         if self.closed.get() {

             )));

             return;

         }

         // The callback is going to be called before other commands are sent,

         // therefore it is safe to queue the callback at this point, as next

                             handler(r.map_err(|e| ControlPortError::ProtocolError(e)));

                         }));

                     }

                         this.async_failure();

                     }

                 }

             }),

         );

     }

 }

 impl Drop for ControlPortInner {

         Ok(Self(ControlPortInner::new(Rc::from(socket))?))

     }

     // TODO: Keep only the methods speicifc to commands and remove this one

     // (tor-browser#44930).

     #[inline]

     }

     #[inline]

         self.0.set_async_handler(cb);

     }

 }

 use thiserror::Error;

 #[derive(Error, Debug, Clone, PartialEq, Eq)]

 pub enum ControlPortError {

     ProtocolError(#[from] ReplyError),

 }

     }

     /// Register the handler for async notifications.

         // Reentrancy safety: we do not use the handler yet.

     }

     /// Feed data to parse.

         let dispatcher = ReplyDispatcher::new();

         let notification_called = Rc::new(Cell::new(false));

         let notification_called2 = notification_called.clone();

             assert_eq!(

                 *r.end_line(),

                 EndReplyLine {

                 }

             );

             notification_called2.set(true);

         let reply_called = Rc::new(Cell::new(false));

         let reply_called2 = reply_called.clone();

         dispatcher.push_callback(Box::new(move |_| {

     #[test]

     fn async_replace_handler() {

         let dispatcher = ReplyDispatcher::new();

             unreachable!("This handler should never be called, as it has been replaced.");

         let called = Rc::new(Cell::new(false));

         let c = called.clone();

             assert_eq!(

                 *r.end_line(),

                 EndReplyLine {

                 }

             );

             c.set(true);

         assert!(!called.get());

         dispatcher

             .feed(&Bytes::from_static(b"650 Notification\r\n"))

         assert!(called.get());

     }

     #[test]

     fn sync_async_single_feed() {

         let dispatcher = ReplyDispatcher::new();

         }));

         let async_called = Rc::new(Cell::new(false));

         let ac = async_called.clone();

             assert_eq!(

                 *r.end_line(),

                 EndReplyLine {

                 }

             );

             ac.set(true);

         dispatcher

             .feed(&Bytes::from_static(b"250 OK\r\n650 Notification\r\n"))

             .unwrap();

         let notifications = Rc::new(Cell::new(0));

         let n = notifications.clone();

         let d = dispatcher.clone();

             n.set(n.get() + 1);

             if n.get() < 2 {

                 d.feed(&Bytes::from_static(b"650 Notification 2\r\n"))

                     .unwrap();

             }

         dispatcher

             .feed(&Bytes::from_static(b"650 Notification 1\r\n"))

             .unwrap();

     #[test]

     fn error_propagation() {

         let dispatcher = ReplyDispatcher::new();

             unreachable!("Errors should not be propagated to the async handler.");

         let first = Rc::new(Cell::new(false));

         let f = first.clone();

         let second = Rc::new(Cell::new(false));

 pub use dispatcher::ReplyDispatcher;

 pub use error::ReplyError;

 pub use line::{DetailReplyLine, EndReplyLine};

 pub use reply::Reply;

 use bytes::Bytes;

 use super::{

     line::{DetailReplyLine, EndReplyLine},

     reply::Reply,

 };

 pub(super) fn check_250_ok(reply: &Reply, has_details: bool) {

     assert_eq!(reply.has_details(), has_details);

     assert_eq!(

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 use nserror::nsresult;

 use nserror::{NS_ERROR_NOT_CONNECTED, NS_OK};

 use nsstring::{nsACString, nsCString};

 use xpcom::RefPtr;

 use super::control_socket::ControlSocketXpcom;

 pub struct ControlPortXpcom {

     control_port: ControlPort,

 }

         Ok(Self::allocate(InitControlPortXpcom { control_port }))

     }

         let receiver = RefPtr::new(receiver);

         Ok(())

     }

     pub fn send_command(

         &self,

         command: &nsACString,

     ) -> Result<(), nsresult> {

         let handler = RefPtr::new(handler);

         self.control_port.send_command(

             Box::new(move |reply| {

                 let mut buf = Vec::new();

                 let reply = match reply {

 use nserror::{nsresult, NS_ERROR_NULL_POINTER, NS_OK};

 use nsstring::nsACString;

 use xpcom::RefPtr;

 use super::control_port::ControlPortXpcom;

 struct TorService {}

 impl TorService {

         TorService::allocate(InitTorService {})

     }

     fn create_control_port(

         &self,

         host: &nsACString,

         port: i32,

     ) -> Result<(), nsresult> {

         if out.is_null() {

             return Err(NS_ERROR_NULL_POINTER);

         }

         cp.forget(unsafe { &mut *out });

         Ok(())

     }

     fn create_control_port_ipc(

         &self,

         socket: &nsIFile,

     ) -> Result<(), nsresult> {

         if out.is_null() {

             return Err(NS_ERROR_NULL_POINTER);

         }

         cp.forget(unsafe { &mut *out });

         Ok(())

     }

 // See toolkit/components/extensions/storage/webext_storage_bridge/src/lib.rs.

 #[no_mangle]

     if result.is_null() {

         return NS_ERROR_NULL_POINTER;

     }

     let service = TorService::new();

     NS_OK

 }

   "nsIXULAppInfo": "appinfo",

   "nsIXULRuntime": "appinfo",

   "nsIXULStore": "xulStore",

 }