[DevTools] Migrate from AgentStateCallbacks to DevToolsAgentHostObserver.

content/browser/devtools/devtools_agent_host_impl.cc

 // Copyright (c) 2012 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 "content/browser/devtools/devtools_agent_host_impl.h"
 
 #include <map>
 #include <vector>
 
+#include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
+#include "base/message_loop/message_loop.h"
+#include "base/observer_list.h"
 #include "content/browser/devtools/devtools_manager.h"
 #include "content/browser/devtools/forwarding_agent_host.h"
 #include "content/browser/devtools/protocol/devtools_protocol_dispatcher.h"
 #include "content/browser/devtools/render_frame_devtools_agent_host.h"
 #include "content/browser/devtools/service_worker_devtools_agent_host.h"
 #include "content/browser/devtools/service_worker_devtools_manager.h"
 #include "content/browser/devtools/shared_worker_devtools_agent_host.h"
 #include "content/browser/devtools/shared_worker_devtools_manager.h"
+#include "content/browser/loader/netlog_observer.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/content_browser_client.h"
 
 namespace content {
 
 namespace {
 typedef std::map<std::string, DevToolsAgentHostImpl*> Instances;
 base::LazyInstance<Instances>::Leaky g_instances = LAZY_INSTANCE_INITIALIZER;
 
-using AgentStateCallbacks =
-    std::vector<const DevToolsAgentHost::AgentStateCallback*>;
-base::LazyInstance<AgentStateCallbacks>::Leaky g_callbacks =
-    LAZY_INSTANCE_INITIALIZER;
-using DiscoveryCallbacks =
-    std::vector<DevToolsAgentHost::DiscoveryCallback>;
+base::LazyInstance<base::ObserverList<DevToolsAgentHostObserver>>::Leaky
+    g_observers = LAZY_INSTANCE_INITIALIZER;
 }  // namespace
 
 char DevToolsAgentHost::kTypePage[] = "page";
 char DevToolsAgentHost::kTypeFrame[] = "iframe";
 char DevToolsAgentHost::kTypeSharedWorker[] = "shared_worker";
 char DevToolsAgentHost::kTypeServiceWorker[] = "service_worker";
 char DevToolsAgentHost::kTypeExternal[] = "external";
 char DevToolsAgentHost::kTypeBrowser[] = "browser";
 char DevToolsAgentHost::kTypeOther[] = "other";
+int DevToolsAgentHostImpl::s_attached_count_ = 0;
 
 // static
 std::string DevToolsAgentHost::GetProtocolVersion() {
   return std::string(devtools::kProtocolVersion);
 }
 
 // static
 bool DevToolsAgentHost::IsSupportedProtocolVersion(const std::string& version) {
   return devtools::IsSupportedProtocolVersion(version);
 }
@@ skipping 78 matching lines @@
     return false;
 
   scoped_refptr<DevToolsAgentHostImpl> protect(this);
   ++session_id_;
   if (client_) {
     client_->AgentHostClosed(this, true);
     InnerDetach();
   }
   client_ = client;
   Attach();
+  NotifyAttached();
   return true;
 }
 
 bool DevToolsAgentHostImpl::AttachClient(DevToolsAgentHostClient* client) {
   return InnerAttach(client, false);
 }
 
 void DevToolsAgentHostImpl::ForceAttachClient(DevToolsAgentHostClient* client) {
   InnerAttach(client, true);
 }
@@ skipping 12 matching lines @@
     DevToolsAgentHostClient* client,
     const std::string& message) {
   if (!client_ || client_ != client)
     return false;
   return DispatchProtocolMessage(message);
 }
 
 void DevToolsAgentHostImpl::InnerDetach() {
   Detach();
   io_context_.DiscardAllStreams();
+  NotifyDetached();
 }
 
 bool DevToolsAgentHostImpl::IsAttached() {
   return !!client_;
 }
 
 void DevToolsAgentHostImpl::InspectElement(
     DevToolsAgentHostClient* client,
     int x,
     int y) {
@@ skipping 61 matching lines @@
 
 void DevToolsAgentHostImpl::HostClosed() {
   if (!client_)
     return;
 
   scoped_refptr<DevToolsAgentHostImpl> protect(this);
   // Clear |client_| before notifying it.
   DevToolsAgentHostClient* client = client_;
   client_ = NULL;
   client->AgentHostClosed(this, false);
+  NotifyDetached();
 }
 
 void DevToolsAgentHostImpl::InspectElement(int x, int y) {
 }
 
 void DevToolsAgentHostImpl::SendMessageToClient(int session_id,
                                                 const std::string& message) {
   if (!client_)
     return;
   // Filter any messages from previous sessions.
@@ skipping 17 matching lines @@
       // Clear |client_| before notifying it.
       DevToolsAgentHostClient* client = agent_host->client_;
       agent_host->client_ = NULL;
       client->AgentHostClosed(agent_host, true);
       agent_host->InnerDetach();
     }
   }
 }
 
 // static
-void DevToolsAgentHost::AddAgentStateCallback(
-    const AgentStateCallback& callback) {
-  g_callbacks.Get().push_back(&callback);
+void DevToolsAgentHost::AddObserver(DevToolsAgentHostObserver* observer) {
+  g_observers.Get().AddObserver(observer);
 }
 
 // static
-void DevToolsAgentHost::RemoveAgentStateCallback(
-    const AgentStateCallback& callback) {
-  if (g_callbacks == NULL)
-    return;
-
-  AgentStateCallbacks* callbacks_ = g_callbacks.Pointer();
-  AgentStateCallbacks::iterator it =
-      std::find(callbacks_->begin(), callbacks_->end(), &callback);
-  DCHECK(it != callbacks_->end());
-  callbacks_->erase(it);
+void DevToolsAgentHost::RemoveObserver(DevToolsAgentHostObserver* observer) {
+  g_observers.Get().RemoveObserver(observer);
 }
 
-// static
-void DevToolsAgentHostImpl::NotifyCallbacks(
-    DevToolsAgentHostImpl* agent_host, bool attached) {
-  AgentStateCallbacks copy(g_callbacks.Get());
-  DevToolsManager* manager = DevToolsManager::GetInstance();
-  manager->AgentHostStateChanged(agent_host, attached);
-  if (manager->delegate())
-    manager->delegate()->DevToolsAgentStateChanged(agent_host, attached);
-  for (AgentStateCallbacks::iterator it = copy.begin(); it != copy.end(); ++it)
-     (*it)->Run(agent_host, attached);
+void DevToolsAgentHostImpl::NotifyAttached() {
+  if (!s_attached_count_) {
+    BrowserThread::PostTask(
+        BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(&NetLogObserver::Attach,
+                   GetContentClient()->browser()->GetNetLog()));
+  }
+  ++s_attached_count_;
+
+  for (auto& observer : g_observers.Get())
+    observer.DevToolsAgentHostAttached(this);
+}
+
+void DevToolsAgentHostImpl::NotifyDetached() {
+  --s_attached_count_;
+  if (!s_attached_count_) {
+    BrowserThread::PostTask(
+        BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(&NetLogObserver::Detach));
+  }
+
+  for (auto& observer : g_observers.Get())
+    observer.DevToolsAgentHostDetached(this);
 }
 
 // DevToolsMessageChunkProcessor -----------------------------------------------
 
 DevToolsMessageChunkProcessor::DevToolsMessageChunkProcessor(
     const SendMessageCallback& callback)
     : callback_(callback),
       message_buffer_size_(0),
       last_call_id_(0) {
 }
@@ skipping 29 matching lines @@
     if (message_buffer_.size() != message_buffer_size_)
       return false;
     callback_.Run(chunk.session_id, message_buffer_);
     message_buffer_ = std::string();
     message_buffer_size_ = 0;
   }
   return true;
 }
 
 }  // namespace content