Make NotificationService an interface in the content namespace, and switch callers to use it. Mov...

content/browser/tab_contents/tab_contents.cc

 // Copyright (c) 2011 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 "content/browser/tab_contents/tab_contents.h"
 
 #include <cmath>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
@@ skipping 23 matching lines @@
 #include "content/browser/tab_contents/provisional_load_details.h"
 #include "content/browser/tab_contents/tab_contents_delegate.h"
 #include "content/browser/tab_contents/tab_contents_observer.h"
 #include "content/browser/tab_contents/tab_contents_view.h"
 #include "content/browser/tab_contents/title_updated_details.h"
 #include "content/browser/user_metrics.h"
 #include "content/browser/webui/web_ui_factory.h"
 #include "content/common/content_constants.h"
 #include "content/common/content_restriction.h"
 #include "content/common/intents_messages.h"
-#include "content/common/notification_service.h"
+#include "content/public/browser/notification_service.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/navigation_types.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/view_types.h"
 #include "net/base/net_util.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "ui/gfx/codec/png_codec.h"
@@ skipping 160 matching lines @@
 TabContents::~TabContents() {
   is_being_destroyed_ = true;
 
   // Clear out any JavaScript state.
   if (dialog_creator_)
     dialog_creator_->ResetJavaScriptState(this);
 
   NotifyDisconnected();
 
   // Notify any observer that have a reference on this tab contents.
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
       content::NOTIFICATION_TAB_CONTENTS_DESTROYED,
       content::Source<TabContents>(this),
-      NotificationService::NoDetails());
+      content::NotificationService::NoDetails());
 
   // 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()) {
     RenderViewHost* host = render_view_host();
     if (host && host->view())
       host->view()->WillWmDestroy();
   }
@@ skipping 205 matching lines @@
     // |render_view_host()| can be NULL if the user middle clicks a link to open
     // a tab in then background, then closes the tab before selecting it.  This
     // is because closing the tab calls TabContents::Destroy(), which removes
     // the |render_view_host()|; then when we actually destroy the window,
     // OnWindowPosChanged() notices and calls HideContents() (which calls us).
     RenderWidgetHostView* rwhv = GetRenderWidgetHostView();
     if (rwhv)
       rwhv->WasHidden();
   }
 
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
       content::NOTIFICATION_TAB_CONTENTS_HIDDEN,
       content::Source<TabContents>(this),
-      NotificationService::NoDetails());
+      content::NotificationService::NoDetails());
 }
 
 void TabContents::Activate() {
   if (delegate_)
     delegate_->ActivateContents(this);
 }
 
 void TabContents::Deactivate() {
   if (delegate_)
     delegate_->DeactivateContents(this);
@@ skipping 508 matching lines @@
   // Send out a notification that we failed a provisional load with an error.
   ProvisionalLoadDetails details(
       params.is_main_frame,
       controller_.IsURLInPageNavigation(validated_url),
       validated_url,
       std::string(),
       false,
       params.frame_id);
   details.set_error_code(params.error_code);
 
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
       content::NOTIFICATION_FAIL_PROVISIONAL_LOAD_WITH_ERROR,
       content::Source<NavigationController>(&controller_),
       content::Details<ProvisionalLoadDetails>(&details));
 
   FOR_EACH_OBSERVER(TabContentsObserver,
                     observers_,
                     DidFailProvisionalLoad(params.frame_id,
                                            params.is_main_frame,
                                            validated_url,
                                            params.error_code,
@@ skipping 13 matching lines @@
   net::CertStatus cert_status = 0;
   int security_bits = -1;
   int connection_status = 0;
   SSLManager::DeserializeSecurityInfo(security_info,
                                       &cert_id, &cert_status,
                                       &security_bits,
                                       &connection_status);
   LoadFromMemoryCacheDetails details(url, GetRenderProcessHost()->id(),
                                      cert_id, cert_status);
 
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
       content::NOTIFICATION_LOAD_FROM_MEMORY_CACHE,
       content::Source<NavigationController>(&controller_),
       content::Details<LoadFromMemoryCacheDetails>(&details));
 }
 
 void TabContents::OnDidDisplayInsecureContent() {
   UserMetrics::RecordAction(UserMetricsAction("SSL.DisplayedInsecureContent"));
   displayed_insecure_content_ = true;
   SSLManager::NotifySSLInternalStateChanged(&controller());
 }
@@ skipping 52 matching lines @@
 
 void TabContents::OnUpdateZoomLimits(int minimum_percent,
                                      int maximum_percent,
                                      bool remember) {
   minimum_zoom_percent_ = minimum_percent;
   maximum_zoom_percent_ = maximum_percent;
   temporary_zoom_settings_ = !remember;
 }
 
 void TabContents::OnFocusedNodeChanged(bool is_editable_node) {
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
       content::NOTIFICATION_FOCUS_CHANGED_IN_PAGE,
       content::Source<TabContents>(this),
       content::Details<const bool>(&is_editable_node));
 }
 
 void TabContents::OnEnumerateDirectory(int request_id,
                                        const FilePath& path) {
   delegate()->EnumerateDirectory(this, request_id, path);
 }
 
@@ skipping 66 matching lines @@
 
   is_loading_ = is_loading;
   waiting_for_response_ = is_loading;
 
   if (delegate_)
     delegate_->LoadingStateChanged(this);
   NotifyNavigationStateChanged(INVALIDATE_LOAD);
 
   int type = is_loading ? content::NOTIFICATION_LOAD_START :
       content::NOTIFICATION_LOAD_STOP;
-  content::NotificationDetails det = NotificationService::NoDetails();
+  content::NotificationDetails det = content::NotificationService::NoDetails();
   if (details)
       det = content::Details<LoadNotificationDetails>(details);
-  NotificationService::current()->Notify(type,
+  content::NotificationService::current()->Notify(type,
       content::Source<NavigationController>(&controller_),
       det);
 }
 
 WebUI* TabContents::GetWebUIForCurrentState() {
   // When there is a pending navigation entry, we want to use the pending WebUI
   // that goes along with it to control the basic flags. For example, we want to
   // show the pending URL in the URL bar, so we want the display_url flag to
   // be from the pending entry.
   //
@@ skipping 147 matching lines @@
       return false;  // Nothing changed, don't bother.
 
     page_title_when_no_navigation_entry_ = final_title;
   }
 
   // Lastly, set the title for the view.
   view_->SetPageTitle(final_title);
 
   TitleUpdatedDetails details(entry, explicit_set);
 
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
       content::NOTIFICATION_TAB_CONTENTS_TITLE_UPDATED,
       content::Source<TabContents>(this),
       content::Details<TitleUpdatedDetails>(&details));
 
   return true;
 }
 
 void TabContents::NotifySwapped() {
   // After sending out a swap notification, we need to send a disconnect
   // notification so that clients that pick up a pointer to |this| can NULL the
   // pointer.  See Bug 1230284.
   notify_disconnection_ = true;
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
       content::NOTIFICATION_TAB_CONTENTS_SWAPPED,
       content::Source<TabContents>(this),
-      NotificationService::NoDetails());
+      content::NotificationService::NoDetails());
 }
 
 void TabContents::NotifyConnected() {
   notify_disconnection_ = true;
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
       content::NOTIFICATION_TAB_CONTENTS_CONNECTED,
       content::Source<TabContents>(this),
-      NotificationService::NoDetails());
+      content::NotificationService::NoDetails());
 }
 
 void TabContents::NotifyDisconnected() {
   if (!notify_disconnection_)
     return;
 
   notify_disconnection_ = false;
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
       content::NOTIFICATION_TAB_CONTENTS_DISCONNECTED,
       content::Source<TabContents>(this),
-      NotificationService::NoDetails());
+      content::NotificationService::NoDetails());
 }
 
 RenderViewHostDelegate::View* TabContents::GetViewDelegate() {
   return view_.get();
 }
 
 RenderViewHostDelegate::RendererManagement*
 TabContents::GetRendererManagementDelegate() {
   return &render_manager_;
 }
 
 RendererPreferences TabContents::GetRendererPrefs(
     content::BrowserContext* browser_context) const {
   return renderer_preferences_;
 }
 
 TabContents* TabContents::GetAsTabContents() {
   return this;
 }
 
 content::ViewType TabContents::GetRenderViewType() const {
   return content::VIEW_TYPE_TAB_CONTENTS;
 }
 
 void TabContents::RenderViewCreated(RenderViewHost* render_view_host) {
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_VIEW_HOST_CREATED_FOR_TAB,
       content::Source<TabContents>(this),
       content::Details<RenderViewHost>(render_view_host));
   NavigationEntry* entry = controller_.GetActiveEntry();
   if (!entry)
     return;
 
   // When we're creating views, we're still doing initial setup, so we always
   // use the pending Web UI rather than any possibly existing committed one.
   if (render_manager_.pending_web_ui())
@@ skipping 248 matching lines @@
 }
 
 void TabContents::DidChangeLoadProgress(double progress) {
   if (delegate())
     delegate()->LoadProgressChanged(progress);
 }
 
 void TabContents::DocumentOnLoadCompletedInMainFrame(
     RenderViewHost* render_view_host,
     int32 page_id) {
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
       content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
       content::Source<TabContents>(this),
       content::Details<int>(&page_id));
 }
 
 void TabContents::RequestOpenURL(const GURL& url,
                                  const GURL& referrer,
                                  WindowOpenDisposition disposition,
                                  int64 source_frame_id) {
   TabContents* new_contents = NULL;
@@ skipping 302 matching lines @@
 void TabContents::CreateViewAndSetSizeForRVH(RenderViewHost* rvh) {
   RenderWidgetHostView* rwh_view = view()->CreateViewForWidget(rvh);
   rwh_view->SetSize(view()->GetContainerSize());
 }
 
 bool TabContents::GotResponseToLockMouseRequest(bool allowed) {
   return render_view_host() ?
       render_view_host()->GotResponseToLockMouseRequest(allowed) : false;
 }