devtools: avoid relying on the internal variables for browser

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/command_line.h"
 #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/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/task_management/web_contents_tags.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_dialogs.h"
+#include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_iterator.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/prefs/prefs_tab_helper.h"
 #include "chrome/browser/ui/scoped_tabbed_browser_displayer.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/webui/devtools_ui.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 313 matching lines @@
     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->life_stage_ == kLoadCompleted ||
       window->life_stage_ == kIsDockedSet;
   if (!is_docked_set)
     return NULL;
 
   // Undocked window should have toolbox web contents.
-  if (!window->is_docked_ && !window->toolbox_web_contents_)
+  if (!window->IsDocked() && !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_;
+  return window->IsDocked() ? window->main_web_contents_
+                            : window->toolbox_web_contents_;
 }
 
 // static
 DevToolsWindow* DevToolsWindow::GetInstanceForInspectedWebContents(
     WebContents* inspected_web_contents) {
   if (!inspected_web_contents || g_instances == NULL)
     return NULL;
   DevToolsWindows* instances = g_instances.Pointer();
   for (DevToolsWindows::iterator it(instances->begin()); it != instances->end();
        ++it) {
@@ skipping 122 matching lines @@
       return;
     window->bindings_->AttachTo(agent.get());
     do_open = true;
   }
 
   // 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)
+  if (!window->IsDocked() || do_open)
     window->ScheduleShow(action);
   else
     window->CloseWindow();
 }
 
 // static
 void DevToolsWindow::InspectElement(
     content::WebContents* inspected_web_contents,
     int x,
     int y) {
@@ skipping 15 matching lines @@
   if (life_stage_ == kLoadCompleted) {
     Show(action);
     return;
   }
 
   // Action will be done only after load completed.
   action_on_load_ = action;
 
   if (!can_dock_) {
     // No harm to show always-undocked window right away.
-    is_docked_ = false;
+    dock_requested_ = false;
     Show(DevToolsToggleAction::Show());
   }
 }
 
 void DevToolsWindow::Show(const DevToolsToggleAction& action) {
   if (life_stage_ == kClosing)
     return;
 
   if (action.type() == DevToolsToggleAction::kNoOp)
     return;
 
-  if (is_docked_) {
+  if (IsDocked()) {
     DCHECK(can_dock_);
     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.
@@ skipping 13 matching lines @@
 
     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.
+  Browser* browser = GetBrowser();
   bool should_show_window =
-      !browser_ || (action.type() != DevToolsToggleAction::kInspect);
+      !browser || (action.type() != DevToolsToggleAction::kInspect);
 
-  if (!browser_)
-    CreateDevToolsBrowser();
+  if (!browser)
+    browser = CreateDevToolsBrowser();
 
   if (should_show_window) {
-    browser_->window()->Show();
+    browser->window()->Show();
     main_web_contents_->SetInitialFocus();
   }
   if (toolbox_web_contents_)
     UpdateBrowserWindow();
 
   DoAction(action);
 }
 
 // static
 bool DevToolsWindow::HandleBeforeUnload(WebContents* frontend_contents,
@@ skipping 66 matching lines @@
 
 DevToolsWindow::DevToolsWindow(Profile* profile,
                                WebContents* main_web_contents,
                                DevToolsUIBindings* bindings,
                                WebContents* inspected_web_contents,
                                bool can_dock)
     : profile_(profile),
       main_web_contents_(main_web_contents),
       toolbox_web_contents_(nullptr),
       bindings_(bindings),
-      browser_(nullptr),
-      is_docked_(true),
+      dock_requested_(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.
       life_stage_(can_dock ? kNotLoaded : kIsDockedSet),
       action_on_load_(DevToolsToggleAction::NoOp()),
       intercepted_page_beforeunload_(false) {
   // Set up delegate, so we get fully-functional window immediately.
   // It will not appear in UI though until |life_stage_ == kLoadCompleted|.
   main_web_contents_->SetDelegate(this);
@@ skipping 145 matching lines @@
   }
 
   bindings_->Reattach();
 
   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) {
-  if (is_docked_) {
+  Browser* browser = GetBrowser();
+  if (browser == nullptr) {
     WebContents* inspected_tab = GetInspectedWebContents();
     if (inspected_tab)
       inspected_tab->GetDelegate()->ActivateContents(inspected_tab);
-  } else if (browser_) {
-    browser_->window()->Activate();
+  } else {
+    browser->window()->Activate();
   }
 }
 
 void DevToolsWindow::AddNewContents(WebContents* source,
                                     WebContents* new_contents,
                                     WindowOpenDisposition disposition,
                                     const gfx::Rect& initial_rect,
                                     bool user_gesture,
                                     bool* was_blocked) {
   if (new_contents == toolbox_web_contents_) {
@@ skipping 31 matching lines @@
     toolbox_web_contents_ = new_contents;
 
     // Tag the DevTools toolbox WebContents with its TaskManager specific
     // UserData so that it shows up in the task manager.
     task_management::WebContentsTags::CreateForDevToolsContents(
         toolbox_web_contents_);
   }
 }
 
 void DevToolsWindow::CloseContents(WebContents* source) {
-  CHECK(is_docked_);
+  CHECK(IsDocked());
   life_stage_ = kClosing;
   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 main_web_contents_;
 }
 
 void DevToolsWindow::ContentsZoomChange(bool zoom_in) {
-  DCHECK(is_docked_);
+  DCHECK(IsDocked());
   ui_zoom::PageZoom::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)
@@ skipping 64 matching lines @@
     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 (life_stage_ != kLoadCompleted)
     return;
-  if (is_docked_ && GetInspectedBrowserWindow())
+  bool is_docked = IsDocked();
+  if (is_docked && GetInspectedBrowserWindow()) {
     main_web_contents_->Focus();
-  else if (!is_docked_ && !browser_->window()->IsActive())
-    browser_->window()->Activate();
+  } else if (!is_docked) {
+    Browser* browser = GetBrowser();
+    if (!browser->window()->IsActive())
+      browser->window()->Activate();
+  }
 }
 
 void DevToolsWindow::CloseWindow() {
-  DCHECK(is_docked_);
+  DCHECK(IsDocked());
   life_stage_ = kClosing;
   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);
   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();
   }
 }
 
 void DevToolsWindow::SetIsDocked(bool dock_requested) {
   if (life_stage_ == kClosing)
     return;
 
   DCHECK(can_dock_ || !dock_requested);
   if (!can_dock_)
     dock_requested = false;
 
-  bool was_docked = is_docked_;
-  is_docked_ = dock_requested;
+  bool was_docked = IsDocked();
+  dock_requested_ = dock_requested;
 
   if (life_stage_ != kLoadCompleted) {
     // This is a first time call we waited for to initialize.
     life_stage_ = life_stage_ == kOnLoadFired ? kLoadCompleted : kIsDockedSet;
     if (life_stage_ == kLoadCompleted)
       LoadCompleted();
     return;
   }
 
   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(main_web_contents_));
-    browser_ = NULL;
+    DetachFromBrowser();
   } else if (!dock_requested && was_docked) {
     UpdateBrowserWindow();
   }
 
   Show(DevToolsToggleAction::Show());
 }
 
 void DevToolsWindow::OpenInNewTab(const std::string& url) {
   content::OpenURLParams params(
       GURL(url), content::Referrer(), NEW_FOREGROUND_TAB,
       ui::PAGE_TRANSITION_LINK, false);
   WebContents* inspected_web_contents = GetInspectedWebContents();
   if (!inspected_web_contents || !inspected_web_contents->OpenURL(params)) {
+    Browser* browser = GetBrowser();
     chrome::HostDesktopType host_desktop_type =
-        browser_ ? browser_->host_desktop_type() : chrome::GetActiveDesktop();
+        browser ? browser->host_desktop_type() : chrome::GetActiveDesktop();
 
     chrome::ScopedTabbedBrowserDisplayer displayer(profile_, host_desktop_type);
     chrome::AddSelectedTabWithURL(displayer.browser(), GURL(url),
                                   ui::PAGE_TRANSITION_LINK);
   }
 }
 
 void DevToolsWindow::SetWhitelistedShortcuts(
     const std::string& message) {
   event_forwarder_->SetWhitelistedShortcuts(message);
 }
 
 void DevToolsWindow::InspectedContentsClosing() {
   intercepted_page_beforeunload_ = false;
   life_stage_ = kClosing;
   main_web_contents_->ClosePage();
 }
 
 InfoBarService* DevToolsWindow::GetInfoBarService() {
-  return is_docked_ ?
-      InfoBarService::FromWebContents(GetInspectedWebContents()) :
-      InfoBarService::FromWebContents(main_web_contents_);
+  return IsDocked() ? InfoBarService::FromWebContents(GetInspectedWebContents())
+                    : InfoBarService::FromWebContents(main_web_contents_);
 }
 
 void DevToolsWindow::RenderProcessGone(bool crashed) {
   // 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_) {
+  if (IsDocked()) {
     CloseContents(main_web_contents_);
-  } else if (browser_ && crashed) {
-    browser_->window()->Close();
+  } else if (crashed) {
+    DetachFromBrowser();
   }
 }
 
 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("DevToolsAPI.setInspectedTabId",
                                     &tabId, NULL, NULL);
     }
   }
 
   if (life_stage_ == kClosing)
     return;
 
   // We could be in kLoadCompleted state already if frontend reloads itself.
   if (life_stage_ != kLoadCompleted) {
     // Load is completed when both kIsDockedSet and kOnLoadFired happened.
     // Here we set kOnLoadFired.
     life_stage_ = life_stage_ == kIsDockedSet ? kLoadCompleted : kOnLoadFired;
   }
   if (life_stage_ == kLoadCompleted)
     LoadCompleted();
 }
 
-void DevToolsWindow::CreateDevToolsBrowser() {
+Browser* DevToolsWindow::CreateDevToolsBrowser() {
   PrefService* prefs = profile_->GetPrefs();
   if (!prefs->GetDictionary(prefs::kAppWindowPlacement)->HasKey(kDevToolsApp)) {
     DictionaryPrefUpdate update(prefs, prefs::kAppWindowPlacement);
     base::DictionaryValue* wp_prefs = update.Get();
     base::DictionaryValue* dev_tools_defaults = new base::DictionaryValue;
     wp_prefs->Set(kDevToolsApp, dev_tools_defaults);
     dev_tools_defaults->SetInteger("left", 100);
     dev_tools_defaults->SetInteger("top", 100);
     dev_tools_defaults->SetInteger("right", 740);
     dev_tools_defaults->SetInteger("bottom", 740);
     dev_tools_defaults->SetBoolean("maximized", false);
     dev_tools_defaults->SetBoolean("always_on_top", false);
   }
 
-  browser_ = new Browser(Browser::CreateParams::CreateForDevTools(
-      profile_,
-      chrome::GetHostDesktopTypeForNativeView(
-          main_web_contents_->GetNativeView())));
-  browser_->tab_strip_model()->AddWebContents(
-      main_web_contents_, -1, ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
-      TabStripModel::ADD_ACTIVE);
+  Browser* browser = new Browser(Browser::CreateParams::CreateForDevTools(
+      profile_, chrome::GetHostDesktopTypeForNativeView(
+                    main_web_contents_->GetNativeView())));
+  browser->tab_strip_model()->AddWebContents(main_web_contents_, -1,
+                                             ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
+                                             TabStripModel::ADD_ACTIVE);
   main_web_contents_->GetRenderViewHost()->SyncRendererPrefs();
+  return browser;
 }
 
 BrowserWindow* DevToolsWindow::GetInspectedBrowserWindow() {
   Browser* browser = NULL;
   int tab;
   return FindInspectedBrowserAndTabIndex(GetInspectedWebContents(),
                                          &browser, &tab) ?
       browser->window() : NULL;
 }
 
@@ skipping 37 matching lines @@
   if (inspected_window)
     inspected_window->UpdateToolbar(NULL);
 }
 
 void DevToolsWindow::UpdateBrowserWindow() {
   BrowserWindow* inspected_window = GetInspectedBrowserWindow();
   if (inspected_window)
     inspected_window->UpdateDevTools();
 }
 
+Browser* DevToolsWindow::GetBrowser() {
+  return chrome::FindBrowserWithWebContents(main_web_contents_);
+}
+
+bool DevToolsWindow::IsDocked() {
+  if (GetBrowser() != nullptr)
+    return false;
+  return dock_requested_;
+}
+
+void DevToolsWindow::DetachFromBrowser() {
+  Browser* browser = GetBrowser();
+  if (browser) {
+    // 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(main_web_contents_));
+  }
+}
+
 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 (life_stage_ == kLoadCompleted || life_stage_ == kClosing) {
     if (!closure.is_null())
       closure.Run();
     return;
   }
   load_completed_callback_ = closure;
 }
 
 bool DevToolsWindow::ForwardKeyboardEvent(
     const content::NativeWebKeyboardEvent& event) {
   return event_forwarder_->ForwardEvent(event);
 }