Move histograms and supporting code that don't belong in content out.

chrome/browser/ui/unload_controller.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/ui/unload_controller.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
+#include "chrome/browser/ui/tab_contents/core_tab_helper.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_delegate.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 
@@ skipping 194 matching lines @@
     ClearUnloadState(contents);
 }
 
 bool UnloadController::DetachWebContents(content::WebContents* contents) {
   int index = browser_->tab_strip_model()->GetIndexOfWebContents(contents);
   if (index != TabStripModel::kNoTab &&
       contents->NeedToFireBeforeUnload()) {
     tabs_needing_unload_ack_.insert(contents);
     browser_->tab_strip_model()->DetachWebContentsAt(index);
     contents->SetDelegate(detached_delegate_.get());
-    contents->OnUnloadDetachedStarted();
+    CoreTabHelper* core_tab_helper = CoreTabHelper::FromWebContents(contents);
+    core_tab_helper->OnUnloadDetachedStarted();
     return true;
   }
   return false;
 }
 
 void UnloadController::ProcessPendingTabs() {
   if (!is_attempting_to_close_browser_) {
     // Because we might invoke this after a delay it's possible for the value of
     // is_attempting_to_close_browser_ to have changed since we scheduled the
     // task.
     return;
   }
 
   if (tab_needing_before_unload_ack_ != NULL) {
     // Wait for |BeforeUnloadFired| before proceeding.
     return;
   }
 
   // Process a beforeunload handler.
   if (!tabs_needing_before_unload_.empty()) {
     WebContentsSet::iterator it = tabs_needing_before_unload_.begin();
     content::WebContents* contents = *it;
     tabs_needing_before_unload_.erase(it);
     // Null check render_view_host here as this gets called on a PostTask and
     // the tab's render_view_host may have been nulled out.
     if (contents->GetRenderViewHost()) {
       tab_needing_before_unload_ack_ = contents;
-      contents->OnCloseStarted();
+
+      CoreTabHelper* core_tab_helper = CoreTabHelper::FromWebContents(contents);
+      core_tab_helper->OnCloseStarted();
+
       contents->GetRenderViewHost()->FirePageBeforeUnload(false);
     } else {
       ProcessPendingTabs();
     }
     return;
   }
 
   // Process all the unload handlers. (The beforeunload handlers have finished.)
   if (!tabs_needing_unload_.empty()) {
     browser_->OnWindowClosing();
 
     // Run unload handlers detached since no more interaction is possible.
     WebContentsSet::iterator it = tabs_needing_unload_.begin();
     while (it != tabs_needing_unload_.end()) {
       WebContentsSet::iterator current = it++;
       content::WebContents* contents = *current;
       tabs_needing_unload_.erase(current);
       // Null check render_view_host here as this gets called on a PostTask
       // and the tab's render_view_host may have been nulled out.
       if (contents->GetRenderViewHost()) {
-        contents->OnUnloadStarted();
+        CoreTabHelper* core_tab_helper =
+            CoreTabHelper::FromWebContents(contents);
+        core_tab_helper->OnUnloadStarted();
         DetachWebContents(contents);
         contents->GetRenderViewHost()->ClosePage();
       }
     }
 
     // Get the browser hidden.
     if (browser_->tab_strip_model()->empty()) {
       browser_->TabStripEmpty();
     } else {
       browser_->tab_strip_model()->CloseAllTabs();  // tabs not needing unload
@@ skipping 21 matching lines @@
       tab_needing_before_unload_ack_ == NULL &&
       tabs_needing_unload_.empty() &&
       tabs_needing_unload_ack_.empty();
 }
 
 void UnloadController::CancelWindowClose() {
   // Closing of window can be canceled from a beforeunload handler.
   DCHECK(is_attempting_to_close_browser_);
   tabs_needing_before_unload_.clear();
   if (tab_needing_before_unload_ack_ != NULL) {
-    tab_needing_before_unload_ack_->OnCloseCanceled();
+
+    CoreTabHelper* core_tab_helper =
+        CoreTabHelper::FromWebContents(tab_needing_before_unload_ack_);
+    core_tab_helper->OnCloseCanceled();
     tab_needing_before_unload_ack_ = NULL;
   }
   for (WebContentsSet::iterator it = tabs_needing_unload_.begin();
        it != tabs_needing_unload_.end(); it++) {
     content::WebContents* contents = *it;
-    contents->OnCloseCanceled();
+
+    CoreTabHelper* core_tab_helper = CoreTabHelper::FromWebContents(contents);
+    core_tab_helper->OnCloseCanceled();
   }
   tabs_needing_unload_.clear();
 
   // No need to clear tabs_needing_unload_ack_. Those tabs are already detached.
 
   is_attempting_to_close_browser_ = false;
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_BROWSER_CLOSE_CANCELLED,
       content::Source<Browser>(browser_),
@@ skipping 24 matching lines @@
 }
 
 void UnloadController::PostTaskForProcessPendingTabs() {
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&UnloadController::ProcessPendingTabs,
                  weak_factory_.GetWeakPtr()));
 }
 
 }  // namespace chrome