[cast_channel] Make CastSocketService a global leaky singleton

extensions/browser/api/cast_channel/cast_channel_api.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef EXTENSIONS_BROWSER_API_CAST_CHANNEL_CAST_CHANNEL_API_H_
 #define EXTENSIONS_BROWSER_API_CAST_CHANNEL_CAST_CHANNEL_API_H_
 
 #include <memory>
 #include <string>
 
@@ skipping 42 matching lines @@
   // Returns a test CastSocket instance, if it is defined.
   // Otherwise returns a scoped_ptr with a nullptr value.
   std::unique_ptr<cast_channel::CastSocket> GetSocketForTest();
 
   // Returns the API browser context.
   content::BrowserContext* GetBrowserContext() const;
 
   // Sends an event to the extension's EventRouter, if it exists.
   void SendEvent(const std::string& extension_id, std::unique_ptr<Event> event);
 
+  // Registers |extension_id| with |observer_| and returns |observer_|.
+  cast_channel::CastSocket::Observer* GetObserver(
+      const std::string& extension_id,
+      scoped_refptr<cast_channel::Logger> logger);
+
  private:
   friend class BrowserContextKeyedAPIFactory<CastChannelAPI>;
   friend class ::CastChannelAPITest;
   friend class CastTransportDelegate;
 
+  // Defines a callback used to send events to the extension's
+  // EventRouter.
+  //     Parameter #0 is a scoped pointer to the event payload.

[imcheng, 2017/07/11 01:31:15]

Update the comments here, but also see mfoltz@'s other comment about extension
ids.

[zhaobin, 2017/07/12 21:58:08]

Done.

+  using EventDispatchCallback =
+      base::Callback<void(const std::string&, std::unique_ptr<Event>)>;
+
+  // Receives incoming messages and errors and provides additional API context.
+  class CastMessageHandler : public cast_channel::CastSocket::Observer {
+   public:
+    CastMessageHandler(const EventDispatchCallback& ui_dispatch_cb,
+                       scoped_refptr<cast_channel::Logger> logger);
+    ~CastMessageHandler() override;
+
+    // CastSocket::Observer implementation.
+    void OnError(const cast_channel::CastSocket& socket,
+                 cast_channel::ChannelError error_state) override;
+    void OnMessage(const cast_channel::CastSocket& socket,
+                   const cast_channel::CastMessage& message) override;
+
+    void RegisterExtensionId(const std::string& extension_id);
+
+   private:
+    // Callback for sending events to the extension.
+    // Should be bound to a weak pointer, to prevent any use-after-free
+    // conditions.
+    EventDispatchCallback const ui_dispatch_cb_;
+    // Logger object for reporting error details.
+    scoped_refptr<cast_channel::Logger> logger_;
+    // Extension IDs call open channel function with this observer.
+    std::set<std::string> extension_ids_;
+
+    THREAD_CHECKER(thread_checker_);
+
+    DISALLOW_COPY_AND_ASSIGN(CastMessageHandler);
+  };
+
   ~CastChannelAPI() override;
 
   // BrowserContextKeyedAPI implementation.
   static const char* service_name() { return "CastChannelAPI"; }
 
   content::BrowserContext* const browser_context_;
   std::unique_ptr<cast_channel::CastSocket> socket_for_test_;
+  // Created and destroyed on the IO thread.
+  std::unique_ptr<CastMessageHandler, content::BrowserThread::DeleteOnIOThread>
+      observer_;
 
   DISALLOW_COPY_AND_ASSIGN(CastChannelAPI);
 };
 
 class CastChannelAsyncApiFunction : public AsyncApiFunction {
  public:
   CastChannelAsyncApiFunction();
 
  protected:
   ~CastChannelAsyncApiFunction() override;
 
   // AsyncApiFunction:
   bool PrePrepare() override;
   bool Respond() override;
 
   // Sets the function result to a ChannelInfo obtained from the state of
   // |socket|.
   void SetResultFromSocket(const cast_channel::CastSocket& socket);
 
   // Sets the function result to a ChannelInfo populated with |channel_id| and
   // |error|.
   void SetResultFromError(int channel_id,
                           api::cast_channel::ChannelError error);
 
-  // Manages creating and removing Cast sockets.
-  scoped_refptr<cast_channel::CastSocketService> cast_socket_service_;
+  // Raw pointer of leaky singleton CastSocketService, which manages creating
+  // and removing Cast sockets.
+  cast_channel::CastSocketService* cast_socket_service_;
 
  private:
   // Sets the function result from |channel_info|.
   void SetResultFromChannelInfo(
       const api::cast_channel::ChannelInfo& channel_info);
 };
 
 class CastChannelOpenFunction : public CastChannelAsyncApiFunction {
  public:
   CastChannelOpenFunction();
 
  protected:
   ~CastChannelOpenFunction() override;
 
   // AsyncApiFunction:
   bool PrePrepare() override;
   bool Prepare() override;
   void AsyncWorkStart() override;
 
  private:
   DECLARE_EXTENSION_FUNCTION("cast.channel.open", CAST_CHANNEL_OPEN)
 
-  // Defines a callback used to send events to the extension's
-  // EventRouter.
-  //     Parameter #0 is a scoped pointer to the event payload.
-  using EventDispatchCallback = base::Callback<void(std::unique_ptr<Event>)>;
-
-  // Receives incoming messages and errors and provides additional API context.
-  class CastMessageHandler : public cast_channel::CastSocket::Observer {
-   public:
-    CastMessageHandler(const EventDispatchCallback& ui_dispatch_cb,
-                       scoped_refptr<cast_channel::Logger> logger);
-    ~CastMessageHandler() override;
-
-    // CastSocket::Observer implementation.
-    void OnError(const cast_channel::CastSocket& socket,
-                 cast_channel::ChannelError error_state) override;
-    void OnMessage(const cast_channel::CastSocket& socket,
-                   const cast_channel::CastMessage& message) override;
-
-   private:
-    // Callback for sending events to the extension.
-    // Should be bound to a weak pointer, to prevent any use-after-free
-    // conditions.
-    EventDispatchCallback const ui_dispatch_cb_;
-    // Logger object for reporting error details.
-    scoped_refptr<cast_channel::Logger> logger_;
-
-    DISALLOW_COPY_AND_ASSIGN(CastMessageHandler);
-  };
-
   // Validates that |connect_info| represents a valid IP end point and returns a
   // new IPEndPoint if so.  Otherwise returns nullptr.
   static net::IPEndPoint* ParseConnectInfo(
       const api::cast_channel::ConnectInfo& connect_info);
 
   void OnOpen(int channel_id, cast_channel::ChannelError result);
 
   std::unique_ptr<api::cast_channel::Open::Params> params_;
   CastChannelAPI* api_;
   std::unique_ptr<net::IPEndPoint> ip_endpoint_;
@@ skipping 44 matching lines @@
 
   std::unique_ptr<api::cast_channel::Close::Params> params_;
   CastChannelAPI* api_;
 
   DISALLOW_COPY_AND_ASSIGN(CastChannelCloseFunction);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_CAST_CHANNEL_CAST_CHANNEL_API_H_