DevTools: support cross-navigation instrumentation.

chrome/browser/debugger/devtools_manager.cc

 // Copyright (c) 2009 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 "chrome/browser/debugger/devtools_manager.h"
 
+#include <vector>
+
 #include "base/message_loop.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browsing_instance.h"
 #include "chrome/browser/child_process_security_policy.h"
 #include "chrome/browser/debugger/devtools_window.h"
 #include "chrome/browser/debugger/devtools_client_host.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/site_instance.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
@@ skipping 33 matching lines @@
 
 void DevToolsManager::RegisterDevToolsClientHostFor(
     RenderViewHost* inspected_rvh,
     DevToolsClientHost* client_host) {
   DCHECK(!GetDevToolsClientHostFor(inspected_rvh));
 
   inspected_rvh_to_client_host_[inspected_rvh] = client_host;
   client_host_to_inspected_rvh_[client_host] = inspected_rvh;
   client_host->set_close_listener(this);
 
-  SendAttachToAgent(inspected_rvh);
+  SendAttachToAgent(inspected_rvh, std::set<std::string>());
 }
 
 void DevToolsManager::ForwardToDevToolsAgent(
     RenderViewHost* client_rvh,
     const IPC::Message& message) {
   DevToolsClientHost* client_host = FindOnwerDevToolsClientHost(client_rvh);
   if (client_host)
     ForwardToDevToolsAgent(client_host, message);
 }
 
@@ skipping 56 matching lines @@
 }
 
 void DevToolsManager::OpenDevToolsWindow(RenderViewHost* inspected_rvh) {
   ToggleDevToolsWindow(inspected_rvh, true);
 }
 
 void DevToolsManager::ToggleDevToolsWindow(RenderViewHost* inspected_rvh) {
   ToggleDevToolsWindow(inspected_rvh, false);
 }
 
+void DevToolsManager::RuntimeFeatureStateChanged(RenderViewHost* inspected_rvh,
+                                                 const std::string& feature,
+                                                 bool enabled) {
+  RuntimeFeaturesMap::iterator it = runtime_features_.find(inspected_rvh);
+  if (it == runtime_features_.end()) {
+    std::pair<RenderViewHost*, std::set<std::string> > value(
+        inspected_rvh,
+        std::set<std::string>());
+    it = runtime_features_.insert(value).first;
+  }
+  if (enabled)
+    it->second.insert(feature);
+  else
+    it->second.erase(feature);
+}
+
 void DevToolsManager::InspectElement(RenderViewHost* inspected_rvh,
                                      int x,
                                      int y) {
   OpenDevToolsWindow(inspected_rvh);
   IPC::Message* m = new DevToolsAgentMsg_InspectElement(x, y);
   m->set_routing_id(inspected_rvh->routing_id());
   inspected_rvh->Send(m);
 }
 
 void DevToolsManager::ClientHostClosing(DevToolsClientHost* host) {
   RenderViewHost* inspected_rvh = GetInspectedRenderViewHost(host);
   if (!inspected_rvh)
     return;
   SendDetachToAgent(inspected_rvh);
 
   inspected_rvh_to_client_host_.erase(inspected_rvh);
+  runtime_features_.erase(inspected_rvh);
   client_host_to_inspected_rvh_.erase(host);
 }
 
 RenderViewHost* DevToolsManager::GetInspectedRenderViewHost(
     DevToolsClientHost* client_host) {
   ClientHostToInspectedRvhMap::iterator it =
       client_host_to_inspected_rvh_.find(client_host);
   if (it != client_host_to_inspected_rvh_.end())
     return it->second;
   return NULL;
 }
 
 void DevToolsManager::UnregisterDevToolsClientHostFor(
       RenderViewHost* inspected_rvh) {
   DevToolsClientHost* host = GetDevToolsClientHostFor(inspected_rvh);
   if (!host)
     return;
   inspected_rvh_to_client_host_.erase(inspected_rvh);
+  runtime_features_.erase(inspected_rvh);
+
   client_host_to_inspected_rvh_.erase(host);
   if (inspected_rvh_for_reopen_ == inspected_rvh)
     inspected_rvh_for_reopen_ = NULL;
 
   // Issue tab closing event post unbound.
   host->InspectedTabClosing();
 
   int process_id = inspected_rvh->process()->id();
   for (InspectedRvhToClientHostMap::iterator it =
            inspected_rvh_to_client_host_.begin();
@@ skipping 10 matching lines @@
                                                  RenderViewHost* dest_rvh,
                                                  const GURL& gurl) {
   if (in_initial_show_) {
     // Mute this even in case it is caused by the initial show routines.
     return;
   }
   DevToolsClientHost* client_host =
       GetDevToolsClientHostFor(rvh);
   if (client_host) {
     // Navigating to URL in the inspected window.
+    std::set<std::string> runtime_features = runtime_features_[rvh];
     inspected_rvh_to_client_host_.erase(rvh);
+    runtime_features_.erase(rvh);
     inspected_rvh_to_client_host_[dest_rvh] = client_host;
     client_host_to_inspected_rvh_[client_host] = dest_rvh;
-    SendAttachToAgent(dest_rvh);
+    SendAttachToAgent(dest_rvh, runtime_features);
     return;
   }
 
   // Iterate over client hosts and if there is one that has render view host
   // changing, reopen entire client window (this must be caused by the user
   // manually refreshing its content).
   for (ClientHostToInspectedRvhMap::iterator it =
            client_host_to_inspected_rvh_.begin();
        it != client_host_to_inspected_rvh_.end(); ++it) {
     DevToolsWindow* window = it->first->AsDevToolsWindow();
     if (window && window->GetRenderViewHost() == rvh) {
       inspected_rvh_for_reopen_ = it->second;
       MessageLoop::current()->PostTask(FROM_HERE,
           NewRunnableMethod(this,
                             &DevToolsManager::ForceReopenWindow));
       return;
     }
   }
 }
 
-void DevToolsManager::SendAttachToAgent(RenderViewHost* inspected_rvh) {
+void DevToolsManager::SendAttachToAgent(
+    RenderViewHost* inspected_rvh,
+    const std::set<std::string>& runtime_features) {
   if (inspected_rvh) {
     ChildProcessSecurityPolicy::GetInstance()->GrantReadRawCookies(
         inspected_rvh->process()->id());
-    IPC::Message* m = new DevToolsAgentMsg_Attach();
+    std::vector<std::string> features(runtime_features.begin(),
+                                      runtime_features.end());
+    IPC::Message* m = new DevToolsAgentMsg_Attach(features);
     m->set_routing_id(inspected_rvh->routing_id());
     inspected_rvh->Send(m);
   }
 }
 
 void DevToolsManager::SendDetachToAgent(RenderViewHost* inspected_rvh) {
   if (inspected_rvh) {
     IPC::Message* m = new DevToolsAgentMsg_Detach();
     m->set_routing_id(inspected_rvh->routing_id());
     inspected_rvh->Send(m);
@@ skipping 72 matching lines @@
   }
 }
 
 void DevToolsManager::CloseWindow(DevToolsClientHost* client_host) {
   RenderViewHost* inspected_rvh = GetInspectedRenderViewHost(client_host);
   DCHECK(inspected_rvh);
   SendDetachToAgent(inspected_rvh);
 
   UnregisterDevToolsClientHostFor(inspected_rvh);
 }