Moving notification types which are chrome specific to a new header file chrome_notification_type...

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 181 matching lines @@
       temporary_zoom_settings_(false),
       content_restrictions_(0) {
 
   render_manager_.Init(profile, site_instance, routing_id);
 
   // We have the initial size of the view be based on the size of the passed in
   // tab contents (normally a tab from the same window).
   view_->CreateView(base_tab_contents ?
       base_tab_contents->view()->GetContainerSize() : gfx::Size());
 
-  registrar_.Add(this, NotificationType::RENDER_WIDGET_HOST_DESTROYED,
+  registrar_.Add(this, content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
                  NotificationService::AllSources());
 
   // Can only add observers after render_manager_.Init() is called, since that's
   // what sets up the render_view_host which TabContentObserver's constructor
   // uses to get the routing_id.
   AddObservers();
 }
 
 TabContents::~TabContents() {
   is_being_destroyed_ = true;
 
   // We don't want any notifications while we're running our destructor.
   registrar_.RemoveAll();
 
   // Clear out any JavaScript state.
   if (delegate_)
     delegate_->GetJavaScriptDialogCreator()->ResetJavaScriptState(this);
 
   NotifyDisconnected();
 
   // First cleanly close all child windows.
   // TODO(mpcomplete): handle case if MaybeCloseChildWindows() already asked
   // some of these to close.  CloseWindows is async, so it might get called
   // twice before it runs.
   CloseConstrainedWindows();
 
   // Notify any observer that have a reference on this tab contents.
   NotificationService::current()->Notify(
-      NotificationType::TAB_CONTENTS_DESTROYED,
+      content::NOTIFICATION_TAB_CONTENTS_DESTROYED,
       Source<TabContents>(this),
       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())
@@ skipping 205 matching lines @@
     // 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(
-      NotificationType::TAB_CONTENTS_HIDDEN,
+      content::NOTIFICATION_TAB_CONTENTS_HIDDEN,
       Source<TabContents>(this),
       NotificationService::NoDetails());
 }
 
 void TabContents::Activate() {
   if (delegate_)
     delegate_->ActivateContents(this);
 }
 
 void TabContents::Deactivate() {
@@ skipping 414 matching lines @@
     render_manager_.RendererAbortedProvisionalLoad(render_view_host());
   }
 
   // Send out a notification that we failed a provisional load with an error.
   ProvisionalLoadDetails details(
       is_main_frame, controller_.IsURLInPageNavigation(validated_url),
       validated_url, std::string(), false, frame_id);
   details.set_error_code(error_code);
 
   NotificationService::current()->Notify(
-      NotificationType::FAIL_PROVISIONAL_LOAD_WITH_ERROR,
+      content::NOTIFICATION_FAIL_PROVISIONAL_LOAD_WITH_ERROR,
       Source<NavigationController>(&controller_),
       Details<ProvisionalLoadDetails>(&details));
 
   FOR_EACH_OBSERVER(TabContentsObserver, observers_,
                     DidFailProvisionalLoad(frame_id, is_main_frame,
                     validated_url, error_code));
 }
 
 void TabContents::OnDidLoadResourceFromMemoryCache(
     const GURL& url,
     const std::string& security_info) {
   base::StatsCounter cache("WebKit.CacheHit");
   cache.Increment();
 
   // Send out a notification that we loaded a resource from our memory cache.
   int cert_id = 0, cert_status = 0, security_bits = -1, 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(
-      NotificationType::LOAD_FROM_MEMORY_CACHE,
+      content::NOTIFICATION_LOAD_FROM_MEMORY_CACHE,
       Source<NavigationController>(&controller_),
       Details<LoadFromMemoryCacheDetails>(&details));
 }
 
 void TabContents::OnDidDisplayInsecureContent() {
   UserMetrics::RecordAction(UserMetricsAction("SSL.DisplayedInsecureContent"));
   displayed_insecure_content_ = true;
   SSLManager::NotifySSLInternalStateChanged();
 }
 
@@ skipping 39 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(
-      NotificationType::FOCUS_CHANGED_IN_PAGE,
+      content::NOTIFICATION_FOCUS_CHANGED_IN_PAGE,
       Source<TabContents>(this),
       Details<const bool>(&is_editable_node));
 }
 
 // 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();
     upload_size_ = 0;
     upload_position_ = 0;
   }
 
   render_manager_.SetIsLoading(is_loading);
 
   is_loading_ = is_loading;
   waiting_for_response_ = is_loading;
 
   if (delegate_)
     delegate_->LoadingStateChanged(this);
   NotifyNavigationStateChanged(INVALIDATE_LOAD);
 
-  NotificationType type = is_loading ? NotificationType::LOAD_START :
-      NotificationType::LOAD_STOP;
+  int type = is_loading ? content::NOTIFICATION_LOAD_START :
+      content::NOTIFICATION_LOAD_STOP;
   NotificationDetails det = NotificationService::NoDetails();
   if (details)
       det = Details<LoadNotificationDetails>(details);
   NotificationService::current()->Notify(type,
       Source<NavigationController>(&controller_),
       det);
 }
 
 WebUI* TabContents::GetWebUIForCurrentState() {
   // When there is a pending navigation entry, we want to use the pending WebUI
@@ skipping 171 matching lines @@
 
     page_title_when_no_navigation_entry_ = final_title;
   }
 
   // Lastly, set the title for the view.
   view_->SetPageTitle(UTF16ToWideHack(final_title));
 
   TitleUpdatedDetails details(entry, explicit_set);
 
   NotificationService::current()->Notify(
-      NotificationType::TAB_CONTENTS_TITLE_UPDATED,
+      content::NOTIFICATION_TAB_CONTENTS_TITLE_UPDATED,
       Source<TabContents>(this),
       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(
-      NotificationType::TAB_CONTENTS_SWAPPED,
+      content::NOTIFICATION_TAB_CONTENTS_SWAPPED,
       Source<TabContents>(this),
       NotificationService::NoDetails());
 }
 
 void TabContents::NotifyConnected() {
   notify_disconnection_ = true;
   NotificationService::current()->Notify(
-      NotificationType::TAB_CONTENTS_CONNECTED,
+      content::NOTIFICATION_TAB_CONTENTS_CONNECTED,
       Source<TabContents>(this),
       NotificationService::NoDetails());
 }
 
 void TabContents::NotifyDisconnected() {
   if (!notify_disconnection_)
     return;
 
   notify_disconnection_ = false;
   NotificationService::current()->Notify(
-      NotificationType::TAB_CONTENTS_DISCONNECTED,
+      content::NOTIFICATION_TAB_CONTENTS_DISCONNECTED,
       Source<TabContents>(this),
       NotificationService::NoDetails());
 }
 
 RenderViewHostDelegate::View* TabContents::GetViewDelegate() {
   return view_.get();
 }
 
 RenderViewHostDelegate::RendererManagement*
 TabContents::GetRendererManagementDelegate() {
   return &render_manager_;
 }
 
 RendererPreferences TabContents::GetRendererPrefs(Profile* profile) const {
   return renderer_preferences_;
 }
 
 TabContents* TabContents::GetAsTabContents() {
   return this;
 }
 
 ViewType::Type TabContents::GetRenderViewType() const {
   return ViewType::TAB_CONTENTS;
 }
 
 void TabContents::RenderViewCreated(RenderViewHost* render_view_host) {
   NotificationService::current()->Notify(
-      NotificationType::RENDER_VIEW_HOST_CREATED_FOR_TAB,
+      content::NOTIFICATION_RENDER_VIEW_HOST_CREATED_FOR_TAB,
       Source<TabContents>(this),
       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())
     render_manager_.pending_web_ui()->RenderViewCreated(render_view_host);
@@ skipping 251 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(
-      NotificationType::LOAD_COMPLETED_MAIN_FRAME,
+      content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
       Source<TabContents>(this),
       Details<int>(&page_id));
 }
 
 void TabContents::RequestOpenURL(const GURL& url, const GURL& referrer,
                                  WindowOpenDisposition disposition) {
   if (render_manager_.web_ui()) {
     // When we're a Web UI, it will provide a page transition type for us (this
     // is so the new tab page can specify AUTO_BOOKMARK for automatically
     // generated suggestions).
@@ skipping 242 matching lines @@
   // linux. See crbug.com/83941.
   if (RenderWidgetHost* render_widget_host = rwh_view->GetRenderWidgetHost())
     render_widget_host->WasResized();
 #endif
 
   UpdateMaxPageIDIfNecessary(render_view_host->site_instance(),
                              render_view_host);
   return true;
 }
 
-void TabContents::Observe(NotificationType type,
+void TabContents::Observe(int type,
                           const NotificationSource& source,
                           const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::RENDER_WIDGET_HOST_DESTROYED:
+  switch (type) {
+    case content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED:
       view_->RenderWidgetHostDestroyed(Source<RenderWidgetHost>(source).ptr());
       break;
     default:
       NOTREACHED();
   }
 }
 
 // Overridden from JavaScriptDialogDelegate
 
 void TabContents::OnDialogClosed(IPC::Message* reply_msg,
@@ skipping 31 matching lines @@
 
 void TabContents::CreateViewAndSetSizeForRVH(RenderViewHost* rvh) {
   RenderWidgetHostView* rwh_view = view()->CreateViewForWidget(rvh);
   rwh_view->SetSize(view()->GetContainerSize());
 }
 
 void TabContents::OnOnlineStateChanged(bool online) {
   render_view_host()->Send(new ViewMsg_NetworkStateChanged(
       render_view_host()->routing_id(), online));
 }