[WIP] Make extension APIs work in devtools APIs when docked.

chrome/browser/devtools/devtools_window.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 "chrome/browser/devtools/devtools_window.h"
 
 #include <algorithm>
 
 #include "base/json/json_reader.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_page_zoom.h"
+#include "chrome/browser/extensions/chrome_extension_web_contents_observer.h"
 #include "chrome/browser/file_select_helper.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/prefs/pref_service_syncable.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/browser/ui/browser_iterator.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
@@ skipping 461 matching lines @@
         agent_host, window->bindings_->frontend_host());
   }
   window->ScheduleShow(DevToolsToggleAction::Show());
 }
 
 // static
 DevToolsWindow* DevToolsWindow::ToggleDevToolsWindow(
     content::RenderViewHost* inspected_rvh,
     bool force_open,
     const DevToolsToggleAction& action) {
+  LOG(INFO) << "Toggling devtools window";
+
   scoped_refptr<DevToolsAgentHost> agent(
       DevToolsAgentHost::GetOrCreateFor(inspected_rvh));
   content::DevToolsManager* manager = content::DevToolsManager::GetInstance();
   DevToolsWindow* window = FindDevToolsWindow(agent.get());
   bool do_open = force_open;
   if (!window) {
+    LOG(INFO) << "No window";
+
     Profile* profile = Profile::FromBrowserContext(
         inspected_rvh->GetProcess()->GetBrowserContext());
     content::RecordAction(
         base::UserMetricsAction("DevTools_InspectRenderer"));
     window = Create(profile, GURL(), inspected_rvh, false, false, true);
     manager->RegisterDevToolsClientHostFor(agent.get(),
                                            window->bindings_->frontend_host());
     do_open = true;
   }
 
+  // Attach an extensions WebContentsObserver for the devtools API.
+  content::WebContents* web_contents =
+      content::WebContents::FromRenderViewHost(inspected_rvh);

[pfeldman, 2014/07/10 13:44:36]

I don't think inspected page contents should be involved in this scenario. All
you want is the main devtools web contents, right? DevToolsUIBindings is created
around it.

+  if (web_contents) {
+    LOG(INFO) << "there is no web contents";
+    extensions::ChromeExtensionWebContentsObserver::CreateForWebContents(
+        web_contents);
+  } else {
+    LOG(INFO) << "extensions attached";
+  }
+
+  LOG(INFO) << "attaching to the blah blah";
+  extensions::ChromeExtensionWebContentsObserver::CreateForWebContents(
+      window->web_contents_for_test());
+
   // Update toolbar to reflect DevTools changes.
   window->UpdateBrowserToolbar();
 
   // If window is docked and visible, we hide it on toggle. If window is
   // undocked, we show (activate) it.
   if (!window->is_docked_ || do_open)
     window->ScheduleShow(action);
   else
     window->CloseWindow();
 
@@ skipping 41 matching lines @@
     Browser* inspected_browser = NULL;
     int inspected_tab_index = -1;
     FindInspectedBrowserAndTabIndex(GetInspectedWebContents(),
                                     &inspected_browser,
                                     &inspected_tab_index);
     DCHECK(inspected_browser);
     DCHECK(inspected_tab_index != -1);
 
     // Tell inspected browser to update splitter and switch to inspected panel.
     BrowserWindow* inspected_window = inspected_browser->window();
     main_web_contents_->SetDelegate(this);

[dgozman, 2014/07/09 20:13:36]

The main difference between docked and undocked DevTools is in helpers attached
by browser (TabHelpers::AttachTabHelpers).

My guess is that you need
|extensions::TabHelper::CreateForWebContents(web_contents)| call from there.
If you need to attach a helper, you should do it here.

Not sure why anybody needs to change localStorage of DevTools from extension. Is
that safe? Changing something in DevTools may affect the page it inspects, for
example privileged WebUI page.

[pfeldman, 2014/07/10 13:44:36]

It seems like ExtensionHostMsg_Request is dispatched in
TabHelper::OnMessageReceived which is missing. I wonder if it should move into
extensions::ChromeExtensionWebContentsObserver (along with other
extension-related methods?).

 
     TabStripModel* tab_strip_model = inspected_browser->tab_strip_model();
     tab_strip_model->ActivateTabAt(inspected_tab_index, true);
 
     inspected_window->UpdateDevTools();
     main_web_contents_->SetInitialFocus();
     inspected_window->Show();
     // On Aura, focusing once is not enough. Do it again.
     // Note that focusing only here but not before isn't enough either. We just
     // need to focus twice.
@@ skipping 117 matching lines @@
   main_web_contents_->SetDelegate(this);
   bindings_ = new DevToolsUIBindings(
       main_web_contents_,
       DevToolsUIBindings::ApplyThemeToURL(profile, url));
   // Bindings take ownership over devtools as its delegate.
   bindings_->SetDelegate(this);
 
   g_instances.Get().push_back(this);
 
   // There is no inspected_rvh in case of shared workers.
-  if (inspected_rvh)
+  if (inspected_rvh) {
     inspected_contents_observer_.reset(new ObserverWithAccessor(
         content::WebContents::FromRenderViewHost(inspected_rvh)));
+  }
   event_forwarder_.reset(new DevToolsEventForwarder(this));
+  LOG(INFO) << "Creating function dispatcher for devtools window";
+  extension_dispatcher_.reset(
+      new extensions::ExtensionFunctionDispatcher(profile, this));
 }
 
 // static
 DevToolsWindow* DevToolsWindow::Create(
     Profile* profile,
     const GURL& frontend_url,
     content::RenderViewHost* inspected_rvh,
     bool shared_worker_frontend,
     bool external_frontend,
     bool can_dock) {
@@ skipping 92 matching lines @@
   manager->ClientHostClosing(bindings_->frontend_host());
   manager->RegisterDevToolsClientHostFor(agent_host.get(),
                                          bindings_->frontend_host());
 
   content::NavigationController::LoadURLParams load_url_params(params.url);
   main_web_contents_->GetController().LoadURLWithParams(load_url_params);
   return main_web_contents_;
 }
 
 void DevToolsWindow::ActivateContents(WebContents* contents) {
+  LOG(INFO) << "web contents activated";
+  extensions::ChromeExtensionWebContentsObserver::CreateForWebContents(

[pfeldman, 2014/07/10 13:44:36]

I don't think you want to do this here. Wiring the main web contents should be
sufficient.

+      contents);
+
   if (is_docked_) {
     WebContents* inspected_tab = GetInspectedWebContents();
     inspected_tab->GetDelegate()->ActivateContents(inspected_tab);
   } else {
     browser_->window()->Activate();
   }
 }
 
 void DevToolsWindow::AddNewContents(WebContents* source,
                                     WebContents* new_contents,
                                     WindowOpenDisposition disposition,
                                     const gfx::Rect& initial_pos,
                                     bool user_gesture,
                                     bool* was_blocked) {
+  LOG(INFO) << "web contents added";
+  extensions::ChromeExtensionWebContentsObserver::CreateForWebContents(

[pfeldman, 2014/07/10 13:44:36]

ditto.

+      new_contents);
+
   if (new_contents == toolbox_web_contents_) {
     toolbox_web_contents_->SetDelegate(
         new DevToolsToolboxDelegate(toolbox_web_contents_,
                                     inspected_contents_observer_.get()));
     gfx::Size size = main_web_contents_->GetViewBounds().size();
     if (toolbox_web_contents_->GetRenderWidgetHostView())
       toolbox_web_contents_->GetRenderWidgetHostView()->SetSize(size);
     UpdateBrowserWindow();
     return;
   }
 
   WebContents* inspected_web_contents = GetInspectedWebContents();
   if (inspected_web_contents) {
     inspected_web_contents->GetDelegate()->AddNewContents(
         source, new_contents, disposition, initial_pos, user_gesture,
         was_blocked);
   }
 }
 
 void DevToolsWindow::WebContentsCreated(WebContents* source_contents,
                                         int opener_render_frame_id,
                                         const base::string16& frame_name,
                                         const GURL& target_url,
                                         WebContents* new_contents) {
+  LOG(INFO) << "web contents created on " << target_url;

[pfeldman, 2014/07/10 13:44:35]

ditto.

+  extensions::ChromeExtensionWebContentsObserver::CreateForWebContents(
+      new_contents);
+
   if (target_url.SchemeIs(content::kChromeDevToolsScheme) &&
       target_url.query().find("toolbox=true") != std::string::npos) {
     CHECK(can_dock_);
     toolbox_web_contents_ = new_contents;
   }
 }
 
 void DevToolsWindow::CloseContents(WebContents* source) {
   CHECK(is_docked_);
   // Do this first so that when GetDockedInstanceForInspectedTab is called
@@ skipping 257 matching lines @@
 }
 
 void DevToolsWindow::RenderProcessGone() {
   // Docked DevToolsWindow owns its main_web_contents_ and must delete it.
   // Undocked main_web_contents_ are owned and handled by browser.
   // see crbug.com/369932
   if (is_docked_)
     CloseContents(main_web_contents_);
 }
 
+extensions::WindowController* DevToolsWindow::GetExtensionWindowController()
+    const {
+  return NULL;
+}
+
+content::WebContents* DevToolsWindow::GetAssociatedWebContents() const {
+  return main_web_contents_;
+}
+
+content::WebContents* DevToolsWindow::GetVisibleWebContents() const {
+  return main_web_contents_;
+}
+
 void DevToolsWindow::OnLoadCompleted() {
   // First seed inspected tab id for extension APIs.
   WebContents* inspected_web_contents = GetInspectedWebContents();
   if (inspected_web_contents) {
     SessionTabHelper* session_tab_helper =
         SessionTabHelper::FromWebContents(inspected_web_contents);
     if (session_tab_helper) {
       base::FundamentalValue tabId(session_tab_helper->session_id().id());
       bindings_->CallClientFunction("WebInspector.setInspectedTabId",
           &tabId, NULL, NULL);
@@ skipping 110 matching lines @@
       closure.Run();
     return;
   }
   load_completed_callback_ = closure;
 }
 
 bool DevToolsWindow::ForwardKeyboardEvent(
     const content::NativeWebKeyboardEvent& event) {
   return event_forwarder_->ForwardEvent(event);
 }