[cast_channel] Make CastMessageHandler a CastSocket::Observer instead of CastTransport::Delegate

extensions/browser/api/cast_channel/cast_channel_api.cc

 // 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.
 
 #include "extensions/browser/api/cast_channel/cast_channel_api.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 276 matching lines @@
         *ip_endpoint_, ExtensionsBrowserClient::Get()->GetNetLog(),
         base::TimeDelta::FromMilliseconds(connect_info.timeout.get()
                                               ? *connect_info.timeout
                                               : kDefaultConnectTimeoutMillis),
         liveness_timeout_, ping_interval_, api_->GetLogger(),
         connect_info.capabilities.get() ? *connect_info.capabilities
                                         : CastDeviceCapability::NONE);
   }
   new_channel_id_ = cast_socket_service_->AddSocket(base::WrapUnique(socket));
 
+  auto* observer = cast_socket_service_->GetObserver(extension_->id());
+  if (!observer) {
+    observer =
+        new CastMessageHandler(base::Bind(&CastChannelAPI::SendEvent,
+                                          api_->AsWeakPtr(), extension_->id()),
+                               api_->GetLogger());
+    cast_socket_service_->AddObserver(extension_->id(),
+                                      base::WrapUnique(observer));

[mark a. foltz, 2017/06/20 01:16:44]

Or just pass base::MakeUnique<> here?

[zhaobin, 2017/06/20 17:50:05]

Done.

+  }
+
+  socket->AddObserver(observer);
   // Construct read delegates.
-  std::unique_ptr<CastTransport::Delegate> delegate(
-      base::MakeUnique<CastMessageHandler>(
-          base::Bind(&CastChannelAPI::SendEvent, api_->AsWeakPtr(),
-                     extension_->id()),
-          socket, api_->GetLogger()));
-  socket->Connect(std::move(delegate),
-                  base::Bind(&CastChannelOpenFunction::OnOpen, this));
+  socket->Connect(base::Bind(&CastChannelOpenFunction::OnOpen, this));
 }
 
 void CastChannelOpenFunction::OnOpen(ChannelError result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   VLOG(1) << "Connect finished, OnOpen invoked.";
   // TODO: If we failed to open the CastSocket, we may want to clean up here,
   // rather than relying on the extension to call close(). This can be done by
   // calling RemoveSocket() and api_->GetLogger()->ClearLastError(channel_id).
   if (result != ChannelError::UNKNOWN) {
     CastSocket* socket = cast_socket_service_->GetSocket(new_channel_id_);
@@ skipping 110 matching lines @@
     SetResultFromSocket(*socket);
     // This will delete |socket|.
     cast_socket_service_->RemoveSocket(channel_id);
     api_->GetLogger()->ClearLastError(channel_id);
   }
   AsyncWorkCompleted();
 }
 
 CastChannelOpenFunction::CastMessageHandler::CastMessageHandler(
     const EventDispatchCallback& ui_dispatch_cb,
-    CastSocket* socket,
     scoped_refptr<Logger> logger)
-    : ui_dispatch_cb_(ui_dispatch_cb), socket_(socket), logger_(logger) {
-  DCHECK(socket_);
+    : ui_dispatch_cb_(ui_dispatch_cb), logger_(logger) {
   DCHECK(logger_);
 }
 
 CastChannelOpenFunction::CastMessageHandler::~CastMessageHandler() {
 }
 
 void CastChannelOpenFunction::CastMessageHandler::OnError(
+    const cast_channel::CastSocket& socket,
     ChannelError error_state) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   ChannelInfo channel_info;
-  FillChannelInfo(*socket_, &channel_info);
+  FillChannelInfo(socket, &channel_info);
   channel_info.error_state = api::cast_channel::ToChannelError(error_state);
   ErrorInfo error_info;
-  FillErrorInfo(channel_info.error_state, logger_->GetLastError(socket_->id()),
+  FillErrorInfo(channel_info.error_state, logger_->GetLastError(socket.id()),
                 &error_info);
 
   std::unique_ptr<base::ListValue> results =
       OnError::Create(channel_info, error_info);
   std::unique_ptr<Event> event(new Event(
       events::CAST_CHANNEL_ON_ERROR, OnError::kEventName, std::move(results)));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(ui_dispatch_cb_, base::Passed(std::move(event))));
 }
 
 void CastChannelOpenFunction::CastMessageHandler::OnMessage(
+    const cast_channel::CastSocket& socket,
     const CastMessage& message) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   MessageInfo message_info;
   CastMessageToMessageInfo(message, &message_info);
   ChannelInfo channel_info;
-  FillChannelInfo(*socket_, &channel_info);
+  FillChannelInfo(socket, &channel_info);
   VLOG(1) << "Received message " << ParamToString(message_info)
           << " on channel " << ParamToString(channel_info);
 
   std::unique_ptr<base::ListValue> results =
       OnMessage::Create(channel_info, message_info);
   std::unique_ptr<Event> event(new Event(events::CAST_CHANNEL_ON_MESSAGE,
                                          OnMessage::kEventName,
                                          std::move(results)));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(ui_dispatch_cb_, base::Passed(std::move(event))));
 }
 
-void CastChannelOpenFunction::CastMessageHandler::Start() {
-}
-
 }  // namespace extensions