[DevTools] Add toolbox web contents to show in undocked mode.

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"
@@ skipping 186 matching lines @@
 };
 
 DevToolsWindow::InspectedWebContentsObserver::InspectedWebContentsObserver(
     WebContents* web_contents)
     : WebContentsObserver(web_contents) {
 }
 
 DevToolsWindow::InspectedWebContentsObserver::~InspectedWebContentsObserver() {
 }
 
+class DevToolsToolboxDelegate
+    : public content::WebContentsObserver,
+      public content::WebContentsDelegate {
+ public:
+  explicit DevToolsToolboxDelegate(WebContents* web_contents)
+      : WebContentsObserver(web_contents) { }
+  virtual ~DevToolsToolboxDelegate() { }
+
+  virtual content::WebContents* OpenURLFromTab(
+      content::WebContents* source,
+      const content::OpenURLParams& params) OVERRIDE {
+    DCHECK(source == web_contents());
+    if (!params.url.SchemeIs(content::kChromeDevToolsScheme))
+      return NULL;
+    content::NavigationController::LoadURLParams load_url_params(params.url);
+    source->GetController().LoadURLWithParams(load_url_params);
+    return source;
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DevToolsToolboxDelegate);
+};
+
 // DevToolsWindow -------------------------------------------------------------
 
 const char DevToolsWindow::kDevToolsApp[] = "DevToolsApp";
 
 DevToolsWindow::~DevToolsWindow() {
+  if (toolbox_web_contents_)
+    delete toolbox_web_contents_;
+  UpdateBrowserWindow();
   UpdateBrowserToolbar();
 
   DevToolsWindows* instances = g_instances.Pointer();
   DevToolsWindows::iterator it(
       std::find(instances->begin(), instances->end(), this));
   DCHECK(it != instances->end());
   instances->erase(it);
 }
 
 // static
@@ skipping 30 matching lines @@
   registry->RegisterBooleanPref(
       prefs::kDevToolsPortForwardingDefaultSet,
       false,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterDictionaryPref(
       prefs::kDevToolsPortForwardingConfig,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 // static
-DevToolsWindow* DevToolsWindow::GetDockedInstanceForInspectedTab(
-    WebContents* inspected_web_contents) {
-  DevToolsWindow* window = GetInstanceForInspectedRenderViewHost(
-      inspected_web_contents->GetRenderViewHost());
+content::WebContents* DevToolsWindow::GetWebContentsToShowForInspectedTab(
+    WebContents* inspected_web_contents,
+    DevToolsContentsResizingStrategy* out_strategy) {
+  DevToolsWindow* window = GetInstanceForInspectedWebContents(
+      inspected_web_contents);
   if (!window)
     return NULL;
+
   // Not yet loaded window is treated as docked, but we should not present it
   // until we decided on docking.
   bool is_docked_set = window->load_state_ == kLoadCompleted ||
       window->load_state_ == kIsDockedSet;
-  return window->is_docked_ && is_docked_set ? window : NULL;
+  if (!is_docked_set)
+    return NULL;
+
+  // Undocked window should have toolbox web contents.
+  if (!window->is_docked_ && !window->toolbox_web_contents_)
+    return NULL;
+
+  if (out_strategy)
+    out_strategy->CopyFrom(window->contents_resizing_strategy_);
+
+  return window->is_docked_ ? window->main_web_contents_ :
+      window->toolbox_web_contents_;
 }
 
 // static
 DevToolsWindow* DevToolsWindow::GetInstanceForInspectedRenderViewHost(
       content::RenderViewHost* inspected_rvh) {
   if (!inspected_rvh || !DevToolsAgentHost::HasFor(inspected_rvh))
     return NULL;
 
   scoped_refptr<DevToolsAgentHost> agent(DevToolsAgentHost::GetOrCreateFor(
       inspected_rvh));
@@ skipping 142 matching lines @@
   agent->InspectElement(x, y);
   bool should_measure_time = FindDevToolsWindow(agent.get()) == NULL;
   base::TimeTicks start_time = base::TimeTicks::Now();
   // TODO(loislo): we should initiate DevTools window opening from within
   // renderer. Otherwise, we still can hit a race condition here.
   DevToolsWindow* window = OpenDevToolsWindow(inspected_rvh);
   if (should_measure_time)
     window->inspect_element_start_time_ = start_time;
 }
 
-const DevToolsContentsResizingStrategy&
-DevToolsWindow::GetContentsResizingStrategy() const {
-  return contents_resizing_strategy_;
-}
-
-gfx::Size DevToolsWindow::GetMinimumSize() const {
-  const gfx::Size kMinDevToolsSize = gfx::Size(230, 100);
-  return kMinDevToolsSize;
-}
-
 void DevToolsWindow::ScheduleShow(const DevToolsToggleAction& action) {
   if (load_state_ == kLoadCompleted) {
     Show(action);
     return;
   }
 
   // Action will be done only after load completed.
   action_on_load_ = action;
 
   if (!can_dock_) {
@@ skipping 12 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();
-    web_contents_->SetDelegate(this);
+    main_web_contents_->SetDelegate(this);
 
     TabStripModel* tab_strip_model = inspected_browser->tab_strip_model();
     tab_strip_model->ActivateTabAt(inspected_tab_index, true);
 
     inspected_window->UpdateDevTools();
-    web_contents_->SetInitialFocus();
+    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.
-    web_contents_->SetInitialFocus();
+    main_web_contents_->SetInitialFocus();
 
-    PrefsTabHelper::CreateForWebContents(web_contents_);
-    web_contents_->GetRenderViewHost()->SyncRendererPrefs();
+    PrefsTabHelper::CreateForWebContents(main_web_contents_);
+    main_web_contents_->GetRenderViewHost()->SyncRendererPrefs();
 
     DoAction(action);
     return;
   }
 
   // Avoid consecutive window switching if the devtools window has been opened
   // and the Inspect Element shortcut is pressed in the inspected tab.
   bool should_show_window =
       !browser_ || (action.type() != DevToolsToggleAction::kInspect);
 
   if (!browser_)
     CreateDevToolsBrowser();
 
   if (should_show_window) {
     browser_->window()->Show();
-    web_contents_->SetInitialFocus();
+    main_web_contents_->SetInitialFocus();
   }
+  if (toolbox_web_contents_)
+    UpdateBrowserWindow();
 
   DoAction(action);
 }
 
 // static
 bool DevToolsWindow::HandleBeforeUnload(WebContents* frontend_contents,
     bool proceed, bool* proceed_to_fire_unload) {
   DevToolsWindow* window = AsDevToolsWindow(
       frontend_contents->GetRenderViewHost());
   if (!window)
@@ skipping 13 matching lines @@
   if (!window || window->intercepted_page_beforeunload_)
     return false;
 
   // Not yet loaded frontend will not handle beforeunload.
   if (window->load_state_ != kLoadCompleted)
     return false;
 
   window->intercepted_page_beforeunload_ = true;
   // Handle case of devtools inspecting another devtools instance by passing
   // the call up to the inspecting devtools instance.
-  if (!DevToolsWindow::InterceptPageBeforeUnload(window->web_contents_)) {
-    window->web_contents_->DispatchBeforeUnload(false);
+  if (!DevToolsWindow::InterceptPageBeforeUnload(window->main_web_contents_)) {
+    window->main_web_contents_->DispatchBeforeUnload(false);
   }
   return true;
 }
 
 // static
 bool DevToolsWindow::NeedsToInterceptBeforeUnload(
     WebContents* contents) {
   DevToolsWindow* window =
       DevToolsWindow::GetInstanceForInspectedRenderViewHost(
           contents->GetRenderViewHost());
@@ skipping 19 matching lines @@
 
 // static
 void DevToolsWindow::OnPageCloseCanceled(WebContents* contents) {
   DevToolsWindow *window =
       DevToolsWindow::GetInstanceForInspectedRenderViewHost(
           contents->GetRenderViewHost());
   if (!window)
     return;
   window->intercepted_page_beforeunload_ = false;
   // Propagate to devtools opened on devtools if any.
-  DevToolsWindow::OnPageCloseCanceled(window->web_contents_);
+  DevToolsWindow::OnPageCloseCanceled(window->main_web_contents_);
 }
 
 DevToolsWindow::DevToolsWindow(Profile* profile,
                                const GURL& url,
                                content::RenderViewHost* inspected_rvh,
                                bool can_dock)
     : profile_(profile),
-      web_contents_(WebContents::Create(WebContents::CreateParams(profile))),
+      main_web_contents_(
+          WebContents::Create(WebContents::CreateParams(profile))),
+      toolbox_web_contents_(NULL),
       bindings_(NULL),
       browser_(NULL),
       is_docked_(true),
       can_dock_(can_dock),
       // This initialization allows external front-end to work without changes.
       // We don't wait for docking call, but instead immediately show undocked.
       // Passing "dockSide=undocked" parameter ensures proper UI.
       load_state_(can_dock ? kNotLoaded : kIsDockedSet),
       action_on_load_(DevToolsToggleAction::NoOp()),
       ignore_set_is_docked_(false),
       intercepted_page_beforeunload_(false) {
   // Set up delegate, so we get fully-functional window immediately.
   // It will not appear in UI though until |load_state_ == kLoadCompleted|.
-  web_contents_->SetDelegate(this);
+  main_web_contents_->SetDelegate(this);
   bindings_ = new DevToolsUIBindings(
-      web_contents_,
+      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)
     inspected_contents_observer_.reset(new InspectedWebContentsObserver(
         content::WebContents::FromRenderViewHost(inspected_rvh)));
@@ skipping 70 matching lines @@
 }
 
 // static
 DevToolsWindow* DevToolsWindow::AsDevToolsWindow(
     content::RenderViewHost* window_rvh) {
   if (g_instances == NULL)
     return NULL;
   DevToolsWindows* instances = g_instances.Pointer();
   for (DevToolsWindows::iterator it(instances->begin()); it != instances->end();
        ++it) {
-    if ((*it)->web_contents_->GetRenderViewHost() == window_rvh)
+    if ((*it)->main_web_contents_->GetRenderViewHost() == window_rvh)
       return *it;
   }
   return NULL;
 }
 
 WebContents* DevToolsWindow::OpenURLFromTab(
     WebContents* source,
     const content::OpenURLParams& params) {
-  DCHECK(source == web_contents_);
+  DCHECK(source == main_web_contents_);
   if (!params.url.SchemeIs(content::kChromeDevToolsScheme)) {
     WebContents* inspected_web_contents = GetInspectedWebContents();
     return inspected_web_contents ?
         inspected_web_contents->OpenURL(params) : NULL;
   }
 
   content::DevToolsManager* manager = content::DevToolsManager::GetInstance();
   scoped_refptr<DevToolsAgentHost> agent_host(
       manager->GetDevToolsAgentHostFor(bindings_->frontend_host()));
   if (!agent_host.get())
     return NULL;
   manager->ClientHostClosing(bindings_->frontend_host());
   manager->RegisterDevToolsClientHostFor(agent_host.get(),
                                          bindings_->frontend_host());
 
   content::NavigationController::LoadURLParams load_url_params(params.url);
-  web_contents_->GetController().LoadURLWithParams(load_url_params);
-  return web_contents_;
+  main_web_contents_->GetController().LoadURLWithParams(load_url_params);
+  return main_web_contents_;
 }
 
 void DevToolsWindow::ActivateContents(WebContents* 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) {
+  if (new_contents == toolbox_web_contents_) {
+    toolbox_web_contents_->SetDelegate(
+        new DevToolsToolboxDelegate(toolbox_web_contents_));

[pfeldman, 2014/05/27 15:26:19]

When is the delegate deleted?

[dgozman, 2014/05/29 11:22:23]

Done.

+    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) {
+  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
   // from UpdateDevTools it won't return this instance
   // see crbug.com/372504
   content::DevToolsManager::GetInstance()->ClientHostClosing(
       bindings_->frontend_host());
   // This will prevent any activity after frontend is loaded.
   action_on_load_ = DevToolsToggleAction::NoOp();
   ignore_set_is_docked_ = true;
-  // Update dev tools to reflect removed dev tools window.
-  BrowserWindow* inspected_window = GetInspectedBrowserWindow();
-  if (inspected_window)
-    inspected_window->UpdateDevTools();
-  // In case of docked web_contents_, we own it so delete here.
+  UpdateBrowserWindow();
+  // In case of docked main_web_contents_, we own it so delete here.
   // Embedding DevTools window will be deleted as a result of
   // DevToolsUIBindings destruction.
-  delete web_contents_;
+  delete main_web_contents_;
 }
 
 void DevToolsWindow::ContentsZoomChange(bool zoom_in) {
   DCHECK(is_docked_);
-  chrome_page_zoom::Zoom(web_contents_,
+  chrome_page_zoom::Zoom(main_web_contents_,
       zoom_in ? content::PAGE_ZOOM_IN : content::PAGE_ZOOM_OUT);
 }
 
 void DevToolsWindow::BeforeUnloadFired(WebContents* tab,
                                        bool proceed,
                                        bool* proceed_to_fire_unload) {
   if (!intercepted_page_beforeunload_) {
     // Docked devtools window closed directly.
     if (proceed) {
       content::DevToolsManager::GetInstance()->ClientHostClosing(
@@ skipping 75 matching lines @@
     WebContents* source,
     const blink::WebGestureEvent& event) {
   // Disable pinch zooming.
   return event.type == blink::WebGestureEvent::GesturePinchBegin ||
       event.type == blink::WebGestureEvent::GesturePinchUpdate ||
       event.type == blink::WebGestureEvent::GesturePinchEnd;
 }
 
 void DevToolsWindow::ActivateWindow() {
   if (is_docked_ && GetInspectedBrowserWindow())
-    web_contents_->Focus();
+    main_web_contents_->Focus();
   else if (!is_docked_ && !browser_->window()->IsActive())
     browser_->window()->Activate();
 }
 
 void DevToolsWindow::CloseWindow() {
   DCHECK(is_docked_);
   // This will prevent any activity after frontend is loaded.
   action_on_load_ = DevToolsToggleAction::NoOp();
   ignore_set_is_docked_ = true;
-  web_contents_->DispatchBeforeUnload(false);
+  main_web_contents_->DispatchBeforeUnload(false);
 }
 
 void DevToolsWindow::SetInspectedPageBounds(const gfx::Rect& rect) {
   DevToolsContentsResizingStrategy strategy(rect);
   if (contents_resizing_strategy_.Equals(strategy))
     return;
 
   contents_resizing_strategy_.CopyFrom(strategy);
-  if (is_docked_) {
-    // Update inspected window.
-    BrowserWindow* inspected_window = GetInspectedBrowserWindow();
-    if (inspected_window)
-      inspected_window->UpdateDevTools();
-  }
+  UpdateBrowserWindow();
 }
 
 void DevToolsWindow::SetContentsResizingStrategy(
     const gfx::Insets& insets, const gfx::Size& min_size) {
   DevToolsContentsResizingStrategy strategy(insets, min_size);
   if (contents_resizing_strategy_.Equals(strategy))
     return;
 
   contents_resizing_strategy_.CopyFrom(strategy);
-  if (is_docked_) {
-    // Update inspected window.
-    BrowserWindow* inspected_window = GetInspectedBrowserWindow();
-    if (inspected_window)
-      inspected_window->UpdateDevTools();
-  }
+  UpdateBrowserWindow();
 }
 
 void DevToolsWindow::InspectElementCompleted() {
   if (!inspect_element_start_time_.is_null()) {
     UMA_HISTOGRAM_TIMES("DevTools.InspectElement",
         base::TimeTicks::Now() - inspect_element_start_time_);
     inspect_element_start_time_ = base::TimeTicks();
   }
 }
 
@@ skipping 43 matching lines @@
   }
 
   if (dock_requested == was_docked)
     return;
 
   if (dock_requested && !was_docked) {
     // Detach window from the external devtools browser. It will lead to
     // the browser object's close and delete. Remove observer first.
     TabStripModel* tab_strip_model = browser_->tab_strip_model();
     tab_strip_model->DetachWebContentsAt(
-        tab_strip_model->GetIndexOfWebContents(web_contents_));
+        tab_strip_model->GetIndexOfWebContents(main_web_contents_));
     browser_ = NULL;
   } else if (!dock_requested && was_docked) {
-    // Update inspected window to hide split and reset it.
-    BrowserWindow* inspected_window = GetInspectedBrowserWindow();
-    if (inspected_window)
-      inspected_window->UpdateDevTools();
+    UpdateBrowserWindow();
   }
 
   Show(DevToolsToggleAction::Show());
 }
 
 void DevToolsWindow::OpenInNewTab(const std::string& url) {
   content::OpenURLParams params(
       GURL(url), content::Referrer(), NEW_FOREGROUND_TAB,
       content::PAGE_TRANSITION_LINK, false);
   WebContents* inspected_web_contents = GetInspectedWebContents();
@@ skipping 25 matching lines @@
 void DevToolsWindow::SetWhitelistedShortcuts(
     const std::string& message) {
   event_forwarder_->SetWhitelistedShortcuts(message);
 }
 
 void DevToolsWindow::InspectedContentsClosing() {
   intercepted_page_beforeunload_ = false;
   // This will prevent any activity after frontend is loaded.
   action_on_load_ = DevToolsToggleAction::NoOp();
   ignore_set_is_docked_ = true;
-  web_contents_->GetRenderViewHost()->ClosePage();
+  main_web_contents_->GetRenderViewHost()->ClosePage();
 }
 
 InfoBarService* DevToolsWindow::GetInfoBarService() {
   return is_docked_ ?
       InfoBarService::FromWebContents(GetInspectedWebContents()) :
-      InfoBarService::FromWebContents(web_contents_);
+      InfoBarService::FromWebContents(main_web_contents_);
 }
 
 void DevToolsWindow::RenderProcessGone() {
-  // Docked DevToolsWindow owns its web_contents_ and must delete it.
-  // Undocked web_contents_ are owned and handled by browser.
+  // 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(web_contents_);
+    CloseContents(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());
@@ skipping 23 matching lines @@
     defaults->SetInteger("top", 100);
     defaults->SetInteger("right", 740);
     defaults->SetInteger("bottom", 740);
     defaults->SetBoolean("maximized", false);
     defaults->SetBoolean("always_on_top", false);
   }
 
   browser_ = new Browser(Browser::CreateParams::CreateForDevTools(
       profile_,
       chrome::GetHostDesktopTypeForNativeView(
-          web_contents_->GetNativeView())));
+          main_web_contents_->GetNativeView())));
   browser_->tab_strip_model()->AddWebContents(
-      web_contents_, -1, content::PAGE_TRANSITION_AUTO_TOPLEVEL,
+      main_web_contents_, -1, content::PAGE_TRANSITION_AUTO_TOPLEVEL,
       TabStripModel::ADD_ACTIVE);
-  web_contents_->GetRenderViewHost()->SyncRendererPrefs();
+  main_web_contents_->GetRenderViewHost()->SyncRendererPrefs();
 }
 
 // static
 bool DevToolsWindow::FindInspectedBrowserAndTabIndex(
     WebContents* inspected_web_contents, Browser** browser, int* tab) {
   if (!inspected_web_contents)
     return false;
 
   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
     int tab_index = it->tab_strip_model()->GetIndexOfWebContents(
@@ skipping 49 matching lines @@
       break;
   }
 }
 
 void DevToolsWindow::UpdateBrowserToolbar() {
   BrowserWindow* inspected_window = GetInspectedBrowserWindow();
   if (inspected_window)
     inspected_window->UpdateToolbar(NULL);
 }
 
+void DevToolsWindow::UpdateBrowserWindow() {
+  BrowserWindow* inspected_window = GetInspectedBrowserWindow();
+  if (inspected_window)
+    inspected_window->UpdateDevTools();
+}
+
 WebContents* DevToolsWindow::GetInspectedWebContents() {
   return inspected_contents_observer_ ?
       inspected_contents_observer_->web_contents() : NULL;
 }
 
 void DevToolsWindow::LoadCompleted() {
   Show(action_on_load_);
   action_on_load_ = DevToolsToggleAction::NoOp();
   if (!load_completed_callback_.is_null()) {
     load_completed_callback_.Run();
     load_completed_callback_ = base::Closure();
   }
 }
 
 void DevToolsWindow::SetLoadCompletedCallback(const base::Closure& closure) {
   if (load_state_ == kLoadCompleted) {
     if (!closure.is_null())
       closure.Run();
     return;
   }
   load_completed_callback_ = closure;
 }
 
 bool DevToolsWindow::ForwardKeyboardEvent(
     const content::NativeWebKeyboardEvent& event) {
   return event_forwarder_->ForwardEvent(event);
 }