[DevTools] Implement DevToolsManager::Observer which notifies about target updates.

BUG=398049

Review URL: https://codereview.chromium.org/577923002

Cr-Commit-Position: refs/heads/master@{#297154}

content/browser/devtools/devtools_agent_host_impl.cc

@@ -75,11 +75,10 @@ void DevToolsAgentHostImpl::AttachClient(DevToolsAgentHostClient* client) {
   if (client_) {
     client_->AgentHostClosed(this, true);
     Detach();
-  } else {
-    DevToolsManager::GetInstance()->OnClientAttached();
   }
   client_ = client;
   Attach();
+  DevToolsManager::GetInstance()->AgentHostChanged(this);
 }
 
 void DevToolsAgentHostImpl::DetachClient() {
@@ -88,8 +87,8 @@ void DevToolsAgentHostImpl::DetachClient() {
 
   scoped_refptr<DevToolsAgentHostImpl> protect(this);
   client_ = NULL;
-  DevToolsManager::GetInstance()->OnClientDetached();
   Detach();
+  DevToolsManager::GetInstance()->AgentHostChanged(this);
 }
 
 bool DevToolsAgentHostImpl::IsAttached() {
@@ -125,8 +124,8 @@ void DevToolsAgentHostImpl::HostClosed() {
   // Clear |client_| before notifying it.
   DevToolsAgentHostClient* client = client_;
   client_ = NULL;
-  DevToolsManager::GetInstance()->OnClientDetached();
   client->AgentHostClosed(this, false);
+  DevToolsManager::GetInstance()->AgentHostChanged(this);
 }
 
 void DevToolsAgentHostImpl::SendMessageToClient(const std::string& message) {
@@ -150,9 +149,9 @@ void DevToolsAgentHost::DetachAllClients() {
       // Clear |client_| before notifying it.
       DevToolsAgentHostClient* client = agent_host->client_;
       agent_host->client_ = NULL;
-      DevToolsManager::GetInstance()->OnClientDetached();
       client->AgentHostClosed(agent_host, true);
       agent_host->Detach();
+      DevToolsManager::GetInstance()->AgentHostChanged(protect);
     }
   }
 }

content/browser/devtools/devtools_manager.cc

@@ -6,10 +6,11 @@
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
+#include "content/browser/devtools/devtools_agent_host_impl.h"
 #include "content/browser/devtools/devtools_netlog_observer.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
-#include "content/public/browser/devtools_manager_delegate.h"
+#include "content/public/browser/devtools_target.h"
 
 namespace content {
 
@@ -20,31 +21,106 @@ DevToolsManager* DevToolsManager::GetInstance() {
 
 DevToolsManager::DevToolsManager()
     : delegate_(GetContentClient()->browser()->GetDevToolsManagerDelegate()),
-      client_count_(0) {
+      update_target_list_required_(false),
+      update_target_list_scheduled_(false),
+      update_target_list_callback_(base::Bind(
+          &DevToolsManager::UpdateTargetListThrottled,
+          base::Unretained(this))) {
 }
 
 DevToolsManager::~DevToolsManager() {
-  DCHECK(!client_count_);
+  DCHECK(!attached_hosts_.size());
+  update_target_list_callback_.Cancel();
 }
 
-void DevToolsManager::OnClientAttached() {
-  if (!client_count_) {
-    BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(&DevToolsNetLogObserver::Attach));
+void DevToolsManager::RenderViewCreated(
+    WebContents* web_contents, RenderViewHost* rvh) {
+  if (observer_list_.might_have_observers()) {
+    // Force agent host creation.
+    DevToolsAgentHost::GetOrCreateFor(web_contents);
   }
-  client_count_++;
 }
 
-void DevToolsManager::OnClientDetached() {
-  client_count_--;
-  if (!client_count_) {
-    BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(&DevToolsNetLogObserver::Detach));
+void DevToolsManager::AgentHostChanged(
+    scoped_refptr<DevToolsAgentHost> agent_host) {
+  bool was_attached =
+      attached_hosts_.find(agent_host.get()) != attached_hosts_.end();
+  if (agent_host->IsAttached() && !was_attached) {
+    if (!attached_hosts_.size()) {
+      BrowserThread::PostTask(
+          BrowserThread::IO,
+          FROM_HERE,
+          base::Bind(&DevToolsNetLogObserver::Attach));
+    }
+    attached_hosts_.insert(agent_host.get());
+  } else if (!agent_host->IsAttached() && was_attached) {
+    attached_hosts_.erase(agent_host.get());
+    if (!attached_hosts_.size()) {
+      BrowserThread::PostTask(
+          BrowserThread::IO,
+          FROM_HERE,
+          base::Bind(&DevToolsNetLogObserver::Detach));
+    }
   }
+
+  UpdateTargetList();
+}
+
+void DevToolsManager::AddObserver(Observer* observer) {
+  observer_list_.AddObserver(observer);
+  UpdateTargetList();
+}
+
+void DevToolsManager::RemoveObserver(Observer* observer) {
+  observer_list_.RemoveObserver(observer);
+}
+
+void DevToolsManager::UpdateTargetList() {
+  if (!observer_list_.might_have_observers())
+    return;
+
+  update_target_list_required_ = true;
+  if (!update_target_list_scheduled_)
+    UpdateTargetListThrottled();
+}
+
+void DevToolsManager::UpdateTargetListThrottled() {
+  if (!update_target_list_required_) {
+    update_target_list_scheduled_ = false;
+    return;
+  }
+
+  update_target_list_scheduled_ = true;
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      update_target_list_callback_.callback(),
+      observer_throttle_interval_);
+
+  update_target_list_required_ = false;
+  if (!delegate_) {
+    Observer::TargetList empty_list;
+    NotifyTargetListChanged(empty_list);
+    return;
+  }
+  delegate_->EnumerateTargets(base::Bind(
+      &DevToolsManager::NotifyTargetListChanged,
+      base::Unretained(this)));
+}
+
+void DevToolsManager::NotifyTargetListChanged(
+    const Observer::TargetList& targets) {
+  FOR_EACH_OBSERVER(Observer, observer_list_, TargetListChanged(targets));
+  STLDeleteContainerPointers(targets.begin(), targets.end());
+}
+
+// static
+base::TimeDelta DevToolsManager::observer_throttle_interval_ =
+    base::TimeDelta::FromMilliseconds(500);
+
+// static
+void DevToolsManager::SetObserverThrottleIntervalForTest(
+    base::TimeDelta interval) {
+  observer_throttle_interval_ = interval;
 }
 
 }  // namespace content

content/browser/devtools/devtools_manager.h

@@ -6,20 +6,39 @@
 #define CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_MANAGER_H_
 
 #include <map>
+#include <set>
 #include <string>
 #include <vector>
 
+#include "base/cancelable_callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/singleton.h"
+#include "base/observer_list.h"
+#include "content/common/content_export.h"
+#include "content/public/browser/devtools_manager_delegate.h"
 
 namespace content {
 
-class DevToolsManagerDelegate;
+class DevToolsAgentHost;
+class RenderViewHost;
+class WebContents;
 
 // This class is a singleton that manage global DevTools state for the whole
 // browser.
-class DevToolsManager {
+class CONTENT_EXPORT DevToolsManager {
  public:
+  class Observer {
+   public:
+    virtual ~Observer() {}
+
+    typedef DevToolsManagerDelegate::TargetList TargetList;
+
+    // Called when any target information changed. Targets in the list are
+    // owned by DevToolsManager, so they should not be accessed outside of
+    // this method.
+    virtual void TargetListChanged(const TargetList& targets) {}
+  };
+
   // Returns single instance of this class. The instance is destroyed on the
   // browser main loop exit so this method MUST NOT be called after that point.
   static DevToolsManager* GetInstance();
@@ -28,14 +47,30 @@ class DevToolsManager {
   virtual ~DevToolsManager();
 
   DevToolsManagerDelegate* delegate() const { return delegate_.get(); }
-  void OnClientAttached();
-  void OnClientDetached();
+
+  void AddObserver(Observer* observer);
+  void RemoveObserver(Observer* observer);
+
+  void RenderViewCreated(WebContents* web_contents, RenderViewHost* rvh);
+  void AgentHostChanged(scoped_refptr<DevToolsAgentHost> agent_host);
+
+  static void SetObserverThrottleIntervalForTest(base::TimeDelta interval);
 
  private:
   friend struct DefaultSingletonTraits<DevToolsManager>;
 
+  void UpdateTargetList();
+  void UpdateTargetListThrottled();
+  void NotifyTargetListChanged(const Observer::TargetList& targets);
+
   scoped_ptr<DevToolsManagerDelegate> delegate_;
-  int client_count_;
+  ObserverList<Observer> observer_list_;
+  std::set<DevToolsAgentHost*> attached_hosts_;
+  bool update_target_list_required_;
+  bool update_target_list_scheduled_;
+  base::CancelableClosure update_target_list_callback_;
+
+  static base::TimeDelta observer_throttle_interval_;
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsManager);
 };

content/browser/devtools/devtools_manager_unittest.cc

@@ -6,13 +6,19 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "content/browser/devtools/devtools_manager.h"
+#include "content/browser/devtools/embedded_worker_devtools_manager.h"
 #include "content/browser/devtools/render_view_devtools_agent_host.h"
+#include "content/browser/shared_worker/shared_worker_instance.h"
+#include "content/browser/shared_worker/worker_storage_partition.h"
 #include "content/common/view_messages.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_external_agent_proxy.h"
 #include "content/public/browser/devtools_external_agent_proxy_delegate.h"
+#include "content/public/browser/devtools_target.h"
 #include "content/public/browser/web_contents_delegate.h"
+#include "content/public/test/test_utils.h"
 #include "content/test/test_content_browser_client.h"
 #include "content/test/test_render_view_host.h"
 #include "content/test/test_web_contents.h"
@@ -93,14 +99,129 @@ class TestWebContentsDelegate : public WebContentsDelegate {
   bool renderer_unresponsive_received_;
 };
 
+class TestTarget : public DevToolsTarget {
+ public:
+  explicit TestTarget(scoped_refptr<DevToolsAgentHost> agent_host)
+      : agent_host_(agent_host) {}
+  virtual ~TestTarget() {}
+
+  virtual std::string GetId() const OVERRIDE { return agent_host_->GetId(); }
+  virtual std::string GetParentId() const OVERRIDE { return std::string(); }
+  virtual std::string GetType() const OVERRIDE { return std::string(); }
+  virtual std::string GetTitle() const OVERRIDE {
+    return agent_host_->GetTitle();
+  }
+  virtual std::string GetDescription() const OVERRIDE { return std::string(); }
+  virtual GURL GetURL() const OVERRIDE { return agent_host_->GetURL(); }
+  virtual GURL GetFaviconURL() const OVERRIDE { return GURL(); }
+  virtual base::TimeTicks GetLastActivityTime() const OVERRIDE {
+    return base::TimeTicks();
+  }
+  virtual bool IsAttached() const OVERRIDE { return agent_host_->IsAttached(); }
+  virtual scoped_refptr<DevToolsAgentHost> GetAgentHost() const OVERRIDE {
+    return agent_host_;
+  }
+  virtual bool Activate() const OVERRIDE { return agent_host_->Activate(); }
+  virtual bool Close() const OVERRIDE { return agent_host_->Close(); }
+
+ private:
+  scoped_refptr<DevToolsAgentHost> agent_host_;
+};
+
+class TestDevToolsManagerDelegate : public DevToolsManagerDelegate {
+ public:
+  virtual ~TestDevToolsManagerDelegate() {}
+
+  virtual void Inspect(BrowserContext* browser_context,
+                       DevToolsAgentHost* agent_host) OVERRIDE {}
+
+  virtual void DevToolsAgentStateChanged(DevToolsAgentHost* agent_host,
+                                         bool attached) OVERRIDE {}
+
+  virtual base::DictionaryValue* HandleCommand(
+      DevToolsAgentHost* agent_host,
+      base::DictionaryValue* command) OVERRIDE { return NULL; }
+
+  virtual scoped_ptr<DevToolsTarget> CreateNewTarget(const GURL& url) OVERRIDE {
+    return scoped_ptr<DevToolsTarget>();
+  }
+
+  virtual void EnumerateTargets(TargetCallback callback) OVERRIDE {
+    TargetList result;
+    DevToolsAgentHost::List agents = DevToolsAgentHost::GetOrCreateAll();
+    for (DevToolsAgentHost::List::iterator it = agents.begin();
+         it != agents.end(); ++it) {
+      if ((*it)->GetType() == DevToolsAgentHost::TYPE_WEB_CONTENTS)
+        result.insert(result.begin(), new TestTarget(*it));
+      else
+        result.push_back(new TestTarget(*it));
+    }
+    callback.Run(result);
+  }
+
+  virtual std::string GetPageThumbnailData(const GURL& url) OVERRIDE {
+    return std::string();
+  }
+};
+
+class ContentBrowserClientWithDevTools : public TestContentBrowserClient {
+ public:
+  virtual ~ContentBrowserClientWithDevTools() {}
+  virtual content::DevToolsManagerDelegate*
+      GetDevToolsManagerDelegate() OVERRIDE {
+    return new TestDevToolsManagerDelegate();
+  }
+};
+
+class TestDevToolsManagerObserver : public DevToolsManager::Observer {
+ public:
+  TestDevToolsManagerObserver()
+      : updates_count_(0) {}
+  virtual ~TestDevToolsManagerObserver() {}
+
+  int updates_count() { return updates_count_; }
+  const std::vector<scoped_refptr<DevToolsAgentHost>> hosts() {
+    return hosts_;
+  }
+
+  virtual void TargetListChanged(const TargetList& targets) OVERRIDE {
+    updates_count_++;
+    hosts_.clear();
+    for (TargetList::const_iterator it = targets.begin();
+         it != targets.end(); ++it) {
+      hosts_.push_back((*it)->GetAgentHost());
+    }
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::MessageLoop::QuitClosure());
+  }
+
+ private:
+  int updates_count_;
+  std::vector<scoped_refptr<DevToolsAgentHost>> hosts_;
+};
+
 }  // namespace
 
 class DevToolsManagerTest : public RenderViewHostImplTestHarness {
+ public:
+  DevToolsManagerTest()
+      : old_browser_client_(NULL) {}
+
  protected:
   virtual void SetUp() OVERRIDE {
     RenderViewHostImplTestHarness::SetUp();
     TestDevToolsClientHost::ResetCounters();
+    old_browser_client_ = SetBrowserClientForTesting(&browser_client_);
   }
+
+  virtual void TearDown() OVERRIDE {
+    SetBrowserClientForTesting(old_browser_client_);
+    RenderViewHostImplTestHarness::TearDown();
+  }
+
+  ContentBrowserClientWithDevTools browser_client_;
+  ContentBrowserClient* old_browser_client_;
 };
 
 TEST_F(DevToolsManagerTest, OpenAndManuallyCloseDevToolsClientHost) {
@@ -239,4 +360,88 @@ TEST_F(DevToolsManagerTest, TestExternalProxy) {
   client_host.Close();
 }
 
+TEST_F(DevToolsManagerTest, TestObserver) {
+  GURL url1("data:text/html,<body>Body1</body>");
+  GURL url2("data:text/html,<body>Body2</body>");
+  GURL url3("data:text/html,<body>Body3</body>");
+
+  DevToolsManager* manager = DevToolsManager::GetInstance();
+  DevToolsManager::SetObserverThrottleIntervalForTest(
+      base::TimeDelta::FromMilliseconds(200));
+
+  contents()->NavigateAndCommit(url1);
+  RunAllPendingInMessageLoop();
+
+  scoped_ptr<TestDevToolsManagerObserver> observer(
+      new TestDevToolsManagerObserver());
+  manager->AddObserver(observer.get());
+  RunMessageLoop();
+  // Added observer should get an update.
+  EXPECT_EQ(1, observer->updates_count());
+  EXPECT_EQ(1u, observer->hosts().size());
+  EXPECT_EQ(contents(), observer->hosts()[0]->GetWebContents());
+  EXPECT_EQ(url1.spec(), observer->hosts()[0]->GetURL().spec());
+
+  contents()->NavigateAndCommit(url2);
+  RunAllPendingInMessageLoop();
+  contents()->NavigateAndCommit(url3);
+  RunMessageLoop();
+  // Updates should be coalesced.
+  EXPECT_EQ(2, observer->updates_count());
+  EXPECT_EQ(1u, observer->hosts().size());
+  EXPECT_EQ(contents(), observer->hosts()[0]->GetWebContents());
+  EXPECT_EQ(url3.spec(), observer->hosts()[0]->GetURL().spec());
+
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::MessageLoop::QuitClosure(),
+      base::TimeDelta::FromMilliseconds(250));
+  base::MessageLoop::current()->Run();
+  // Check there were no extra updates.
+  EXPECT_EQ(2, observer->updates_count());
+
+  scoped_ptr<WorkerStoragePartition> partition(new WorkerStoragePartition(
+      browser_context()->GetRequestContext(),
+      NULL, NULL, NULL, NULL, NULL, NULL, NULL));
+  WorkerStoragePartitionId partition_id(*partition.get());
+
+  GURL shared_worker_url("http://example.com/shared_worker.js");
+  SharedWorkerInstance shared_worker(
+      shared_worker_url,
+      base::string16(),
+      base::string16(),
+      blink::WebContentSecurityPolicyTypeReport,
+      browser_context()->GetResourceContext(),
+      partition_id);
+  EmbeddedWorkerDevToolsManager::GetInstance()->SharedWorkerCreated(
+      1, 1, shared_worker);
+  contents()->NavigateAndCommit(url2);
+
+  RunMessageLoop();
+  EXPECT_EQ(3, observer->updates_count());
+  EXPECT_EQ(2u, observer->hosts().size());
+  EXPECT_EQ(contents(), observer->hosts()[0]->GetWebContents());
+  EXPECT_EQ(url2.spec(), observer->hosts()[0]->GetURL().spec());
+  EXPECT_EQ(DevToolsAgentHost::TYPE_SHARED_WORKER,
+            observer->hosts()[1]->GetType());
+  EXPECT_EQ(shared_worker_url.spec(), observer->hosts()[1]->GetURL().spec());
+
+  EmbeddedWorkerDevToolsManager::GetInstance()->WorkerDestroyed(1, 1);
+  RunMessageLoop();
+  EXPECT_EQ(4, observer->updates_count());
+  EXPECT_EQ(1u, observer->hosts().size());
+  EXPECT_EQ(contents(), observer->hosts()[0]->GetWebContents());
+  EXPECT_EQ(url2.spec(), observer->hosts()[0]->GetURL().spec());
+
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::MessageLoop::QuitClosure(),
+      base::TimeDelta::FromMilliseconds(250));
+  base::MessageLoop::current()->Run();
+  // Check there were no extra updates.
+  EXPECT_EQ(4, observer->updates_count());
+
+  manager->RemoveObserver(observer.get());
+}
+
 }  // namespace content

content/browser/devtools/embedded_worker_devtools_manager.cc

@@ -4,6 +4,7 @@
 
 #include "content/browser/devtools/embedded_worker_devtools_manager.h"
 
+#include "content/browser/devtools/devtools_manager.h"
 #include "content/browser/devtools/devtools_protocol.h"
 #include "content/browser/devtools/devtools_protocol_constants.h"
 #include "content/browser/devtools/embedded_worker_devtools_agent_host.h"
@@ -104,6 +105,7 @@ bool EmbeddedWorkerDevToolsManager::SharedWorkerCreated(
   AgentHostMap::iterator it = FindExistingSharedWorkerAgentHost(instance);
   if (it == workers_.end()) {
     workers_[id] = new EmbeddedWorkerDevToolsAgentHost(id, instance);
+    DevToolsManager::GetInstance()->AgentHostChanged(workers_[id]);
     return false;
   }
   WorkerRestarted(id, it);
@@ -121,6 +123,7 @@ bool EmbeddedWorkerDevToolsManager::ServiceWorkerCreated(
   if (it == workers_.end()) {
     workers_[id] = new EmbeddedWorkerDevToolsAgentHost(
         id, service_worker_id, debug_service_worker_on_start_);
+    DevToolsManager::GetInstance()->AgentHostChanged(workers_[id]);
     return debug_service_worker_on_start_;
   }
   WorkerRestarted(id, it);
@@ -133,7 +136,9 @@ void EmbeddedWorkerDevToolsManager::WorkerDestroyed(int worker_process_id,
   const WorkerId id(worker_process_id, worker_route_id);
   AgentHostMap::iterator it = workers_.find(id);
   DCHECK(it != workers_.end());
-  it->second->WorkerDestroyed();
+  scoped_refptr<EmbeddedWorkerDevToolsAgentHost> agent_host(it->second);
+  agent_host->WorkerDestroyed();
+  DevToolsManager::GetInstance()->AgentHostChanged(agent_host);
 }
 
 void EmbeddedWorkerDevToolsManager::WorkerReadyForInspection(
@@ -201,6 +206,7 @@ void EmbeddedWorkerDevToolsManager::WorkerRestarted(
   agent_host->WorkerRestarted(id);
   workers_.erase(it);
   workers_[id] = agent_host;
+  DevToolsManager::GetInstance()->AgentHostChanged(agent_host);
 }
 
 void EmbeddedWorkerDevToolsManager::ResetForTesting() {

content/browser/devtools/render_view_devtools_agent_host.cc

@@ -123,6 +123,7 @@ RenderViewDevToolsAgentHost::RenderViewDevToolsAgentHost(RenderViewHost* rvh)
   power_handler_->SetNotifier(notifier);
   g_instances.Get().push_back(this);
   AddRef();  // Balanced in RenderViewHostDestroyed.
+  DevToolsManager::GetInstance()->AgentHostChanged(this);
 }
 
 WebContents* RenderViewDevToolsAgentHost::GetWebContents() {
@@ -290,6 +291,7 @@ void RenderViewDevToolsAgentHost::RenderViewDeleted(RenderViewHost* rvh) {
   scoped_refptr<RenderViewDevToolsAgentHost> protect(this);
   HostClosed();
   ClearRenderViewHost();
+  DevToolsManager::GetInstance()->AgentHostChanged(this);
   Release();
 }
 
@@ -339,6 +341,16 @@ void RenderViewDevToolsAgentHost::DidDetachInterstitialPage() {
   overrides_handler_->DidDetachInterstitialPage();
 }
 
+void RenderViewDevToolsAgentHost::TitleWasSet(
+    NavigationEntry* entry, bool explicit_set) {
+  DevToolsManager::GetInstance()->AgentHostChanged(this);
+}
+
+void RenderViewDevToolsAgentHost::NavigationEntryCommitted(
+    const LoadCommittedDetails& load_details) {
+  DevToolsManager::GetInstance()->AgentHostChanged(this);
+}
+
 void RenderViewDevToolsAgentHost::Observe(int type,
                                           const NotificationSource& source,
                                           const NotificationDetails& details) {

content/browser/devtools/render_view_devtools_agent_host.h

@@ -76,6 +76,9 @@ class CONTENT_EXPORT RenderViewDevToolsAgentHost
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
   virtual void DidAttachInterstitialPage() OVERRIDE;
   virtual void DidDetachInterstitialPage() OVERRIDE;
+  virtual void TitleWasSet(NavigationEntry* entry, bool explicit_set) OVERRIDE;
+  virtual void NavigationEntryCommitted(
+      const LoadCommittedDetails& load_details) OVERRIDE;
 
   // NotificationObserver overrides:
   virtual void Observe(int type,

content/browser/web_contents/web_contents_impl.cc

@@ -23,7 +23,7 @@
 #include "content/browser/browser_plugin/browser_plugin_embedder.h"
 #include "content/browser/browser_plugin/browser_plugin_guest.h"
 #include "content/browser/child_process_security_policy_impl.h"
-#include "content/browser/devtools/render_view_devtools_agent_host.h"
+#include "content/browser/devtools/devtools_manager.h"
 #include "content/browser/dom_storage/dom_storage_context_wrapper.h"
 #include "content/browser/dom_storage/session_storage_namespace_impl.h"
 #include "content/browser/download/download_stats.h"
@@ -3559,6 +3559,8 @@ void WebContentsImpl::RenderViewCreated(RenderViewHost* render_view_host) {
   FOR_EACH_OBSERVER(
       WebContentsObserver, observers_, RenderFrameCreated(main_frame));
   SetAccessibilityModeOnFrame(accessibility_mode_, main_frame);
+
+  DevToolsManager::GetInstance()->RenderViewCreated(this, render_view_host);
 }
 
 void WebContentsImpl::RenderViewReady(RenderViewHost* rvh) {