Avoid retaining the pointer to inspected WebContents in DevToolsWindow

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 <algorithm>
 
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/stringprintf.h"
@@ skipping 31 matching lines @@
 #include "content/public/browser/devtools_client_host.h"
 #include "content/public/browser/devtools_manager.h"
 #include "content/public/browser/favicon_status.h"
 #include "content/public/browser/load_notification_details.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/page_transition_types.h"
 #include "content/public/common/url_constants.h"
 #include "grit/generated_resources.h"
 
 typedef std::vector<DevToolsWindow*> DevToolsWindowList;
 namespace {
 base::LazyInstance<DevToolsWindowList>::Leaky
@@ skipping 24 matching lines @@
 const char kDockSideBottom[] = "bottom";
 const char kDockSideRight[] = "right";
 const char kDockSideUndocked[] = "undocked";
 
 // Minimal height of devtools pane or content pane when devtools are docked
 // to the browser window.
 const int kMinDevToolsHeight = 50;
 const int kMinDevToolsWidth = 150;
 const int kMinContentsSize = 50;
 
+class DevToolsWindow::InspectedWebContentsObserver
+  : public content::WebContentsObserver {
+ public:
+  explicit InspectedWebContentsObserver(content::WebContents* web_contents)
+    : WebContentsObserver(web_contents) {
+    }
+
+  content::WebContents* Get() { return web_contents(); }
+};
+
 // static
 std::string DevToolsWindow::GetDevToolsWindowPlacementPrefKey() {
   std::string wp_key;
   wp_key.append(prefs::kBrowserWindowPlacement);
   wp_key.append("_");
   wp_key.append(kDevToolsApp);
   return wp_key;
 }
 
 // static
@@ skipping 115 matching lines @@
       process_id, chrome::kFileScheme);
   content::DevToolsClientHost::SetupDevToolsFrontendClient(render_view_host);
   return new DevToolsWindow(web_contents, profile, inspected_rvh, dock_side);
 }
 
 DevToolsWindow::DevToolsWindow(WebContents* web_contents,
                                Profile* profile,
                                RenderViewHost* inspected_rvh,
                                DevToolsDockSide dock_side)
     : profile_(profile),
-      inspected_web_contents_(NULL),
       web_contents_(web_contents),
       browser_(NULL),
       dock_side_(dock_side),
       is_loaded_(false),
       action_on_load_(DEVTOOLS_TOGGLE_ACTION_SHOW),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       width_(-1),
       height_(-1) {
   frontend_host_.reset(
       DevToolsClientHost::CreateDevToolsFrontendHost(web_contents, this));
@@ skipping 14 matching lines @@
       this,
       chrome::NOTIFICATION_TAB_CLOSING,
       content::Source<NavigationController>(&web_contents->GetController()));
   registrar_.Add(
       this,
       chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
       content::Source<ThemeService>(
           ThemeServiceFactory::GetForProfile(profile_)));
   // There is no inspected_rvh in case of shared workers.
   if (inspected_rvh)
-    inspected_web_contents_ = WebContents::FromRenderViewHost(inspected_rvh);
+    inspected_contents_observer_.reset(new InspectedWebContentsObserver(
+        WebContents::FromRenderViewHost(inspected_rvh)));
 }
 
 DevToolsWindow::~DevToolsWindow() {
   DevToolsWindowList& instances = g_instances.Get();
   DevToolsWindowList::iterator it = std::find(instances.begin(),
                                               instances.end(),
                                               this);
   DCHECK(it != instances.end());
   instances.erase(it);
 }
 
+content::WebContents* DevToolsWindow::GetInspectedWebContents() {
+  if (!inspected_contents_observer_)
+    return NULL;
+  return inspected_contents_observer_->Get();
+}
+
 void DevToolsWindow::InspectedContentsClosing() {
   if (IsDocked()) {
     // 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.
     delete web_contents_;
 
     delete this;
@@ skipping 126 matching lines @@
 
   browser_ = new Browser(Browser::CreateParams::CreateForDevTools(
                              profile_, host_desktop_type));
   browser_->tab_strip_model()->AddWebContents(
       web_contents_, -1, content::PAGE_TRANSITION_AUTO_TOPLEVEL,
       TabStripModel::ADD_ACTIVE);
 }
 
 bool DevToolsWindow::FindInspectedBrowserAndTabIndex(Browser** browser,
                                                      int* tab) {
-  if (!inspected_web_contents_)
+  content::WebContents* inspected_web_contents = GetInspectedWebContents();
+  if (!inspected_web_contents)
     return false;
 
   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
     int tab_index = it->tab_strip_model()->GetIndexOfWebContents(
-        inspected_web_contents_);
+        inspected_web_contents);
     if (tab_index != TabStripModel::kNoTab) {
       *browser = *it;
       *tab = tab_index;
       return true;
     }
   }
   return false;
 }
 
 BrowserWindow* DevToolsWindow::GetInspectedBrowserWindow() {
@@ skipping 14 matching lines @@
 
 void DevToolsWindow::UpdateFrontendDockSide() {
   base::StringValue dock_side(SideToString(dock_side_));
   CallClientFunction("InspectorFrontendAPI.setDockSide", &dock_side);
   base::FundamentalValue docked(IsDocked());
   CallClientFunction("InspectorFrontendAPI.setAttachedWindow", &docked);
 }
 
 
 void DevToolsWindow::AddDevToolsExtensionsToClient() {
-  if (inspected_web_contents_) {
+  content::WebContents* inspected_web_contents = GetInspectedWebContents();
+  if (inspected_web_contents) {
     SessionTabHelper* session_tab_helper =
-        SessionTabHelper::FromWebContents(inspected_web_contents_);
+        SessionTabHelper::FromWebContents(inspected_web_contents);
     if (session_tab_helper) {
       base::FundamentalValue tabId(session_tab_helper->session_id().id());
       CallClientFunction("WebInspector.setInspectedTabId", &tabId);
     }
   }
   ListValue results;
   Profile* profile =
       Profile::FromBrowserContext(web_contents_->GetBrowserContext());
   const ExtensionService* extension_service = extensions::ExtensionSystem::Get(
       profile->GetOriginalProfile())->extension_service();
@@ skipping 15 matching lines @@
     extension_info->Set("exposeExperimentalAPIs",
         new base::FundamentalValue(allow_experimental));
     results.Append(extension_info);
   }
   CallClientFunction("WebInspector.addExtensions", &results);
 }
 
 WebContents* DevToolsWindow::OpenURLFromTab(WebContents* source,
                                             const OpenURLParams& params) {
   if (!params.url.SchemeIs(chrome::kChromeDevToolsScheme)) {
-    if (inspected_web_contents_)
-      return inspected_web_contents_->OpenURL(params);
+    content::WebContents* inspected_web_contents = GetInspectedWebContents();
+    if (inspected_web_contents)
+      return inspected_web_contents->OpenURL(params);
     return NULL;
   }
 
   DevToolsManager* manager = DevToolsManager::GetInstance();
   scoped_refptr<DevToolsAgentHost> agent_host(
       manager->GetDevToolsAgentHostFor(frontend_host_.get()));
   if (!agent_host)
     return NULL;
   manager->ClientHostClosing(frontend_host_.get());
   manager->RegisterDevToolsClientHostFor(agent_host, frontend_host_.get());
@@ skipping 124 matching lines @@
   web_contents_->GetRenderViewHost()->
       ExecuteJavascriptInWebFrame(string16(), UTF8ToUTF16(command));
 }
 
 void DevToolsWindow::AddNewContents(WebContents* source,
                                     WebContents* new_contents,
                                     WindowOpenDisposition disposition,
                                     const gfx::Rect& initial_pos,
                                     bool user_gesture,
                                     bool* was_blocked) {
-  if (inspected_web_contents_) {
-    inspected_web_contents_->GetDelegate()->AddNewContents(
+  content::WebContents* inspected_web_contents = GetInspectedWebContents();
+  if (inspected_web_contents) {
+    inspected_web_contents->GetDelegate()->AddNewContents(
         source, new_contents, disposition, initial_pos, user_gesture,
         was_blocked);
   }
 }
 
 bool DevToolsWindow::PreHandleKeyboardEvent(
     WebContents* source,
     const NativeWebKeyboardEvent& event, bool* is_keyboard_shortcut) {
   if (IsDocked()) {
     BrowserWindow* inspected_window = GetInspectedBrowserWindow();
@@ skipping 118 matching lines @@
     bounds.Offset(x, y);
     browser_->window()->SetBounds(bounds);
   }
 }
 
 void DevToolsWindow::SetDockSide(const std::string& side) {
   DevToolsDockSide requested_side = SideFromString(side);
   bool dock_requested = requested_side != DEVTOOLS_DOCK_SIDE_UNDOCKED;
   bool is_docked = IsDocked();
 
-  if (dock_requested && (!inspected_web_contents_ ||
+  content::WebContents* inspected_web_contents = GetInspectedWebContents();
+  if (dock_requested && (!inspected_web_contents ||
       !GetInspectedBrowserWindow() || IsInspectedBrowserPopupOrPanel())) {
       // Cannot dock, avoid window flashing due to close-reopen cycle.
     return;
   }
 
   dock_side_ = requested_side;
   if (dock_requested) {
     if (!is_docked) {
       // Detach window from the external devtools browser. It will lead to
       // the browser object's close and delete. Remove observer first.
@@ skipping 25 matching lines @@
 
   Show(DEVTOOLS_TOGGLE_ACTION_SHOW);
 }
 
 void DevToolsWindow::OpenInNewTab(const std::string& url) {
   OpenURLParams params(GURL(url),
                        content::Referrer(),
                        NEW_FOREGROUND_TAB,
                        content::PAGE_TRANSITION_LINK,
                        false /* is_renderer_initiated */);
-  if (inspected_web_contents_) {
-    inspected_web_contents_->OpenURL(params);
+  content::WebContents* inspected_web_contents = GetInspectedWebContents();
+  if (inspected_web_contents) {
+    inspected_web_contents->OpenURL(params);
   } else {
     chrome::HostDesktopType host_desktop_type;
     if (browser_) {
       host_desktop_type = browser_->host_desktop_type();
     } else {
       // There should always be a browser when there are no inspected web
       // contents.
       NOTREACHED();
       host_desktop_type = chrome::GetActiveDesktop();
     }
@@ skipping 86 matching lines @@
   if (!file_system.file_system_path.empty())
     file_system_value = CreateFileSystemValue(file_system);
   CallClientFunction("InspectorFrontendAPI.fileSystemAdded",
                      &error_string_value,
                      file_system_value);
   if (file_system_value)
     delete file_system_value;
 }
 
 content::JavaScriptDialogManager* DevToolsWindow::GetJavaScriptDialogManager() {
-  if (inspected_web_contents_ && inspected_web_contents_->GetDelegate()) {
-    return inspected_web_contents_->GetDelegate()->
+  content::WebContents* inspected_web_contents = GetInspectedWebContents();
+  if (inspected_web_contents && inspected_web_contents->GetDelegate()) {
+    return inspected_web_contents->GetDelegate()->
         GetJavaScriptDialogManager();
   }
   return content::WebContentsDelegate::GetJavaScriptDialogManager();
 }
 
 void DevToolsWindow::RunFileChooser(WebContents* web_contents,
                                     const FileChooserParams& params) {
   FileSelectHelper::RunFileChooser(web_contents, params);
 }
 
 void DevToolsWindow::WebContentsFocused(WebContents* contents) {
   Browser* inspected_browser = NULL;
   int inspected_tab_index = -1;
 
   if (IsDocked() && FindInspectedBrowserAndTabIndex(&inspected_browser,
                                                     &inspected_tab_index)) {
     inspected_browser->window()->WebContentsFocused(contents);
   }
 }
 
 void DevToolsWindow::UpdateBrowserToolbar() {
-  if (!inspected_web_contents_)
+  content::WebContents* inspected_web_contents = GetInspectedWebContents();
+  if (!inspected_web_contents)
     return;
   BrowserWindow* inspected_window = GetInspectedBrowserWindow();
   if (inspected_window)
-    inspected_window->UpdateToolbar(inspected_web_contents_, false);
+    inspected_window->UpdateToolbar(inspected_web_contents, false);
 }
 
 bool DevToolsWindow::IsDocked() {
   return dock_side_ != DEVTOOLS_DOCK_SIDE_UNDOCKED;
 }
 
 // static
 DevToolsDockSide DevToolsWindow::GetDockSideFromPrefs(Profile* profile) {
   std::string dock_side =
       profile->GetPrefs()->GetString(prefs::kDevToolsDockSide);
@@ skipping 28 matching lines @@
 
 // static
 DevToolsDockSide DevToolsWindow::SideFromString(
     const std::string& dock_side) {
   if (dock_side == kDockSideRight)
     return DEVTOOLS_DOCK_SIDE_RIGHT;
   if (dock_side == kDockSideBottom)
     return DEVTOOLS_DOCK_SIDE_BOTTOM;
   return DEVTOOLS_DOCK_SIDE_UNDOCKED;
 }