Add histogram for how tab closing time. Did some cleanup along the way.

chrome/browser/tab_contents/tab_contents.cc

 // Copyright (c) 2009 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/tab_contents/tab_contents.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/file_version_info.h"
 #include "base/process_util.h"
@@ skipping 247 matching lines @@
       last_search_result_(),
       capturing_contents_(false),
       is_being_destroyed_(false),
       notify_disconnection_(false),
       history_requests_(),
 #if defined(OS_WIN)
       message_box_active_(CreateEvent(NULL, TRUE, FALSE, NULL)),
 #endif
       last_javascript_message_dismissal_(),
       suppress_javascript_messages_(false),
+      is_showing_before_unload_dialog_(false),
       opener_dom_ui_type_(DOMUIFactory::kNoDOMUI) {
   pending_install_.page_id = 0;
   pending_install_.callback_functor = NULL;
 
 #if defined(OS_CHROMEOS)
   // Make sure the thumbnailer is started before starting the render manager.
   // The thumbnailer will want to listen for RVH creations, one of which will
   // happen in RVHManager::Init.
   ThumbnailGenerator* generator = g_browser_process->GetThumbnailGenerator();
   if (generator)
@@ skipping 89 matching lines @@
   }
   infobar_delegates_.clear();
 
   // TODO(brettw) this should be moved to the view.
 #if defined(OS_WIN)
   // If we still have a window handle, destroy it. GetNativeView can return
   // NULL if this contents was part of a window that closed.
   if (GetNativeView())
     ::DestroyWindow(GetNativeView());
 #endif
+
+  // OnCloseStarted isn't called in unit tests.
+  if (!tab_close_start_time_.is_null()) {
+    UMA_HISTOGRAM_TIMES("Tab.Close",
+        base::TimeTicks::Now() - tab_close_start_time_);
+  }
 }
 
 // static
 void TabContents::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kAlternateErrorPagesEnabled, true);
 
   WebPreferences pref_defaults;
   prefs->RegisterBooleanPref(prefs::kWebKitJavascriptEnabled,
                              pref_defaults.javascript_enabled);
   prefs->RegisterBooleanPref(prefs::kWebKitWebSecurityEnabled,
@@ skipping 718 matching lines @@
 }
 
 void TabContents::GetPageLanguage() {
   render_view_host()->GetPageLanguage();
 }
 
 void TabContents::OnJavaScriptMessageBoxClosed(IPC::Message* reply_msg,
                                                bool success,
                                                const std::wstring& prompt) {
   last_javascript_message_dismissal_ = base::TimeTicks::Now();
-  render_manager_.OnJavaScriptMessageBoxClosed(reply_msg, success, prompt);
+  if (is_showing_before_unload_dialog_ && !success) {
+    // If a beforeunload dialog is canceled, we need to stop the throbber from
+    // spinning, since we forced it to start spinning in Navigate.
+    DidStopLoading();
+
+    tab_close_start_time_ = base::TimeTicks();
+  }
+  is_showing_before_unload_dialog_ = false;
+  render_view_host()->JavaScriptMessageBoxClosed(reply_msg, success, prompt);
 }
 
 void TabContents::OnSavePage() {
   // If we can not save the page, try to download it.
   if (!SavePackage::IsSavableContents(contents_mime_type())) {
     DownloadManager* dlm = profile()->GetDownloadManager();
     const GURL& current_page_url = GetURL();
     if (dlm && current_page_url.is_valid())
       dlm->DownloadUrl(current_page_url, GURL(), "", this);
     return;
@@ skipping 47 matching lines @@
 void TabContents::LogNewTabTime(const std::string& event_name) {
   // Not all new tab pages get timed.  In those cases, we don't have a
   // new_tab_start_time_.
   if (new_tab_start_time_.is_null())
     return;
 
   base::TimeDelta duration = base::TimeTicks::Now() - new_tab_start_time_;
   MetricEventDurationDetails details(event_name,
       static_cast<int>(duration.InMilliseconds()));
 
-  if (event_name == "NewTab.ScriptStart") {
-    UMA_HISTOGRAM_TIMES("NewTab.ScriptStart", duration);
-  } else if (event_name == "NewTab.DOMContentLoaded") {
-    UMA_HISTOGRAM_TIMES("NewTab.DOMContentLoaded", duration);
-  } else if (event_name == "NewTab.Onload") {
-    UMA_HISTOGRAM_TIMES("NewTab.Onload", duration);
+  if (event_name == "Tab.NewTabScriptStart") {
+    UMA_HISTOGRAM_TIMES("Tab.NewTabScriptStart", duration);
+  } else if (event_name == "Tab.NewTabDOMContentLoaded") {
+    UMA_HISTOGRAM_TIMES("Tab.NewTabDOMContentLoaded", duration);
+  } else if (event_name == "Tab.NewTabOnload") {
+    UMA_HISTOGRAM_TIMES("Tab.NewTabOnload", duration);
     // The new tab page has finished loading; reset it.
     new_tab_start_time_ = base::TimeTicks();
   } else {
     NOTREACHED();
   }
   NotificationService::current()->Notify(
       NotificationType::METRIC_EVENT_DURATION,
       Source<TabContents>(this),
       Details<MetricEventDurationDetails>(&details));
 }
 
+void TabContents::OnCloseStarted() {
+  if (tab_close_start_time_.is_null())

[tony, 2009/10/14 23:20:06]

Is it possible for this to be called twice?

[jam, 2009/10/14 23:31:11]

Yes it does, since InternalCloseTabs will get called twice for a tab that has
unload handlers.  I wasn't sure if I should duplicate this comment here, since
it's already in the declaration of that function.

+    tab_close_start_time_ = base::TimeTicks::Now();
+}
+
 // Notifies the RenderWidgetHost instance about the fact that the page is
 // loading, or done loading and calls the base implementation.
 void TabContents::SetIsLoading(bool is_loading,
                                LoadNotificationDetails* details) {
   if (is_loading == is_loading_)
     return;
 
   if (!is_loading) {
     load_state_ = net::LOAD_STATE_IDLE;
     load_state_host_.clear();
@@ skipping 933 matching lines @@
   // Ignore this if it comes from a RenderViewHost that we aren't showing.
   if (delegate() && rvh == render_view_host())
     delegate()->CloseContents(this);
 }
 
 void TabContents::RequestMove(const gfx::Rect& new_bounds) {
   if (delegate() && delegate()->IsPopup(this))
     delegate()->MoveContents(this, new_bounds);
 }
 
-void TabContents::DidStartLoading(RenderViewHost* rvh) {
+void TabContents::DidStartLoading() {
   SetIsLoading(true, NULL);
 }
 
-void TabContents::DidStopLoading(RenderViewHost* rvh) {
+void TabContents::DidStopLoading() {
   scoped_ptr<LoadNotificationDetails> details;
 
   NavigationEntry* entry = controller_.GetActiveEntry();
   // An entry may not exist for a stop when loading an initial blank page or
   // if an iframe injected by script into a blank page finishes loading.
   if (entry) {
     scoped_ptr<base::ProcessMetrics> metrics(
         base::ProcessMetrics::CreateProcessMetrics(
             process()->process().handle()));
 
@@ skipping 118 matching lines @@
                             show_suppress_checkbox, reply_msg);
   } else {
     // If we are suppressing messages, just reply as is if the user immediately
     // pressed "Cancel".
     OnJavaScriptMessageBoxClosed(reply_msg, false, std::wstring());
   }
 }
 
 void TabContents::RunBeforeUnloadConfirm(const std::wstring& message,
                                          IPC::Message* reply_msg) {
+  is_showing_before_unload_dialog_ = true;
   RunBeforeUnloadDialog(this, message, reply_msg);
 }
 
 void TabContents::ShowModalHTMLDialog(const GURL& url, int width, int height,
                                       const std::string& json_arguments,
                                       IPC::Message* reply_msg) {
   if (delegate()) {
     HtmlDialogUIDelegate* dialog_delegate =
         new ModalHtmlDialogDelegate(url, width, height, json_arguments,
                                     reply_msg, this);
@@ skipping 292 matching lines @@
 
     default:
       NOTREACHED();
   }
 }
 
 void TabContents::set_encoding(const std::string& encoding) {
   encoding_ = CharacterEncoding::GetCanonicalEncodingNameByAliasName(encoding);
 }