[DevTools] Add explicit closing state in DevToolsWindow life time.

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 345 matching lines @@
       prefs::kDevToolsPortForwardingConfig,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 // static
 content::WebContents* DevToolsWindow::GetInTabWebContents(
     WebContents* inspected_web_contents,
     DevToolsContentsResizingStrategy* out_strategy) {
   DevToolsWindow* window = GetInstanceForInspectedWebContents(
       inspected_web_contents);
-  if (!window)
+  if (!window || window->life_stage_ == kClosing)
     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;
+  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_)
     return NULL;
 
   if (out_strategy)
     out_strategy->CopyFrom(window->contents_resizing_strategy_);
 
@@ skipping 149 matching lines @@
   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;
 }
 
 void DevToolsWindow::ScheduleShow(const DevToolsToggleAction& action) {
-  if (load_state_ == kLoadCompleted) {
+  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;
     Show(DevToolsToggleAction::Show());
   }
 }
 
 void DevToolsWindow::Show(const DevToolsToggleAction& action) {
+  if (life_stage_ == kClosing)
+    return;
+
   if (action.type() == DevToolsToggleAction::kNoOp)
     return;
 
   if (is_docked_) {
     DCHECK(can_dock_);
     Browser* inspected_browser = NULL;
     int inspected_tab_index = -1;
     FindInspectedBrowserAndTabIndex(GetInspectedWebContents(),
                                     &inspected_browser,
                                     &inspected_tab_index);
@@ skipping 54 matching lines @@
 }
 
 // static
 bool DevToolsWindow::InterceptPageBeforeUnload(WebContents* contents) {
   DevToolsWindow* window =
       DevToolsWindow::GetInstanceForInspectedWebContents(contents);
   if (!window || window->intercepted_page_beforeunload_)
     return false;
 
   // Not yet loaded frontend will not handle beforeunload.
-  if (window->load_state_ != kLoadCompleted)
+  if (window->life_stage_ != 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->main_web_contents_)) {
     window->main_web_contents_->DispatchBeforeUnload(false);
   }
   return true;
 }
@@ skipping 42 matching lines @@
       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),
+      life_stage_(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|.
+  // It will not appear in UI though until |life_stage_ == kLoadCompleted|.
   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.
@@ skipping 153 matching lines @@
                                         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;
+  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_);
   chrome_page_zoom::Zoom(main_web_contents_,
@@ skipping 88 matching lines @@
 
 void DevToolsWindow::ActivateWindow() {
   if (is_docked_ && GetInspectedBrowserWindow())
     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;
+  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();
@@ skipping 20 matching lines @@
 void DevToolsWindow::MoveWindow(int x, int y) {
   if (!is_docked_) {
     gfx::Rect bounds = browser_->window()->GetBounds();
     bounds.Offset(x, y);
     browser_->window()->SetBounds(bounds);
   }
 }
 
 void DevToolsWindow::SetIsDockedAndShowImmediatelyForTest(bool is_docked) {
   DCHECK(!is_docked || can_dock_);
-  if (load_state_ == kLoadCompleted) {
+  DCHECK(life_stage_ != kClosing);
+  if (life_stage_ == kLoadCompleted) {
     SetIsDocked(is_docked);
   } else {
     is_docked_ = is_docked;
     // Load is completed when both kIsDockedSet and kOnLoadFired happened.
     // Note that kIsDockedSet may be already set when can_dock_ is false.
-    load_state_ = load_state_ == kOnLoadFired ? kLoadCompleted : kIsDockedSet;
+    life_stage_ = life_stage_ == kOnLoadFired ? kLoadCompleted : kIsDockedSet;
     // Note that action_on_load_ will be performed after the load is actually
     // completed. For now, just show the window.
     Show(DevToolsToggleAction::Show());
-    if (load_state_ == kLoadCompleted)
+    if (life_stage_ == kLoadCompleted)
       LoadCompleted();
   }
   ignore_set_is_docked_ = true;
 }
 
 void DevToolsWindow::SetIsDocked(bool dock_requested) {
-  if (ignore_set_is_docked_)
+  if (ignore_set_is_docked_ || life_stage_ == kClosing)
     return;
 
   DCHECK(can_dock_ || !dock_requested);
   if (!can_dock_)
     dock_requested = false;
 
   bool was_docked = is_docked_;
   is_docked_ = dock_requested;
 
-  if (load_state_ != kLoadCompleted) {
+  if (life_stage_ != kLoadCompleted) {
     // This is a first time call we waited for to initialize.
-    load_state_ = load_state_ == kOnLoadFired ? kLoadCompleted : kIsDockedSet;
-    if (load_state_ == kLoadCompleted)
+    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.
@@ skipping 38 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;
+  life_stage_ = kClosing;
   main_web_contents_->GetRenderViewHost()->ClosePage();
 }
 
 InfoBarService* DevToolsWindow::GetInfoBarService() {
   return is_docked_ ?
       InfoBarService::FromWebContents(GetInspectedWebContents()) :
       InfoBarService::FromWebContents(main_web_contents_);
 }
 
 void DevToolsWindow::RenderProcessGone() {
@@ skipping 10 matching lines @@
   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);
     }
   }
 
+  if (life_stage_ == kClosing)
+    return;
+
   // We could be in kLoadCompleted state already if frontend reloads itself.
-  if (load_state_ != kLoadCompleted) {
+  if (life_stage_ != kLoadCompleted) {
     // Load is completed when both kIsDockedSet and kOnLoadFired happened.
     // Here we set kOnLoadFired.
-    load_state_ = load_state_ == kIsDockedSet ? kLoadCompleted : kOnLoadFired;
+    life_stage_ = life_stage_ == kIsDockedSet ? kLoadCompleted : kOnLoadFired;
   }
-  if (load_state_ == kLoadCompleted)
+  if (life_stage_ == kLoadCompleted)
     LoadCompleted();
 }
 
 void DevToolsWindow::CreateDevToolsBrowser() {
   std::string wp_key = GetDevToolsWindowPlacementPrefKey();
   PrefService* prefs = profile_->GetPrefs();
   const base::DictionaryValue* wp_pref = prefs->GetDictionary(wp_key.c_str());
   if (!wp_pref || wp_pref->empty()) {
     DictionaryPrefUpdate update(prefs, wp_key.c_str());
     base::DictionaryValue* defaults = update.Get();
@@ skipping 78 matching lines @@
 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 (life_stage_ == kLoadCompleted) {
     if (!closure.is_null())
       closure.Run();
     return;
   }
   load_completed_callback_ = closure;
 }
 
 bool DevToolsWindow::ForwardKeyboardEvent(
     const content::NativeWebKeyboardEvent& event) {
   return event_forwarder_->ForwardEvent(event);
 }