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

chrome/browser/instant/instant_loader.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 "chrome/browser/instant/instant_loader.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/i18n/case_conversion.h"
 #include "base/string_number_conversions.h"
 #include "base/timer.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/favicon/favicon_service.h"
 #include "chrome/browser/history/history_marshaling.h"
 #include "chrome/browser/history/history_tab_helper.h"
 #include "chrome/browser/instant/instant_loader_delegate.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/ui/blocked_content/blocked_content_tab_helper.h"
 #include "chrome/browser/ui/download/download_tab_helper.h"
 #include "chrome/browser/ui/download/download_tab_helper_delegate.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper_delegate.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/render_messages.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/render_widget_host.h"
 #include "content/browser/renderer_host/render_widget_host_view.h"
 #include "content/browser/tab_contents/navigation_details.h"
 #include "content/browser/tab_contents/navigation_entry.h"
 #include "content/browser/tab_contents/provisional_load_details.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/tab_contents/tab_contents_delegate.h"
 #include "content/browser/tab_contents/tab_contents_view.h"
+#include "content/common/content_notification_types.h"
 #include "content/common/notification_details.h"
 #include "content/common/notification_observer.h"
 #include "content/common/notification_registrar.h"
 #include "content/common/notification_service.h"
 #include "content/common/notification_source.h"
-#include "content/common/notification_type.h"
 #include "content/common/page_transition_types.h"
 #include "content/common/renderer_preferences.h"
 #include "net/http/http_util.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/codec/png_codec.h"
 
 namespace {
 
 // Number of ms to delay before updating the omnibox bounds. This is only used
 // when the bounds of the omnibox shrinks. If the bounds grows, we update
@@ skipping 15 matching lines @@
  public:
   FrameLoadObserver(InstantLoader* loader,
                     TabContents* tab_contents,
                     const string16& text,
                     bool verbatim)
       : loader_(loader),
         tab_contents_(tab_contents),
         text_(text),
         verbatim_(verbatim),
         unique_id_(tab_contents_->controller().pending_entry()->unique_id()) {
-    registrar_.Add(this, NotificationType::LOAD_COMPLETED_MAIN_FRAME,
+    registrar_.Add(this, content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
                    Source<TabContents>(tab_contents_));
   }
 
   // Sets the text to send to the page.
   void set_text(const string16& text) { text_ = text; }
 
   // Sets whether verbatim results are obtained rather than predictive.
   void set_verbatim(bool verbatim) { verbatim_ = verbatim; }
 
   // NotificationObserver:
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details) OVERRIDE;
 
  private:
   InstantLoader* loader_;
 
   // The TabContents we're listening for changes on.
   TabContents* tab_contents_;
 
   // Text to send down to the page.
   string16 text_;
 
   // Whether verbatim results are obtained.
   bool verbatim_;
 
   // unique_id of the NavigationEntry we're waiting on.
   const int unique_id_;
 
   // Registers and unregisters us for notifications.
   NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(FrameLoadObserver);
 };
 
 void InstantLoader::FrameLoadObserver::Observe(
-    NotificationType type,
+    int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::LOAD_COMPLETED_MAIN_FRAME: {
+  switch (type) {
+    case content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME: {
       int page_id = *(Details<int>(details).ptr());
       NavigationEntry* active_entry =
           tab_contents_->controller().GetActiveEntry();
       if (!active_entry || active_entry->page_id() != page_id ||
           active_entry->unique_id() != unique_id_) {
         return;
       }
       loader_->SendBoundsToPage(true);
       // TODO: support real cursor position.
       int text_length = static_cast<int>(text_.size());
@@ skipping 36 matching lines @@
   void SetLastHistoryURLAndPrune(const GURL& url);
 
   // Commits the currently buffered history.
   void CommitHistory(bool supports_instant);
 
   void RegisterForPaintNotifications(RenderWidgetHost* render_widget_host);
 
   void UnregisterForPaintNotifications();
 
   // NotificationObserver:
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details) OVERRIDE;
 
   // TabContentsDelegate:
   virtual void NavigationStateChanged(const TabContents* source,
                                       unsigned changed_flags) OVERRIDE;
   virtual std::string GetNavigationHeaders(const GURL& url) OVERRIDE;
   virtual bool ShouldFocusConstrainedWindow() OVERRIDE;
   virtual void WillShowConstrainedWindow(TabContents* source) OVERRIDE;
   virtual bool ShouldSuppressDialogs() OVERRIDE;
@@ skipping 71 matching lines @@
 
 InstantLoader::TabContentsDelegateImpl::TabContentsDelegateImpl(
     InstantLoader* loader)
     : TabContentsObserver(loader->preview_contents()->tab_contents()),
       loader_(loader),
       registered_render_widget_host_(NULL),
       waiting_for_new_page_(true),
       is_mouse_down_from_activate_(false),
       user_typed_before_load_(false) {
   DCHECK(loader->preview_contents());
-  registrar_.Add(this, NotificationType::INTERSTITIAL_ATTACHED,
+  registrar_.Add(this, content::NOTIFICATION_INTERSTITIAL_ATTACHED,
       Source<TabContents>(loader->preview_contents()->tab_contents()));
-  registrar_.Add(this, NotificationType::FAIL_PROVISIONAL_LOAD_WITH_ERROR,
+  registrar_.Add(this, content::NOTIFICATION_FAIL_PROVISIONAL_LOAD_WITH_ERROR,
       Source<NavigationController>(&loader->preview_contents()->controller()));
 }
 
 void InstantLoader::TabContentsDelegateImpl::PrepareForNewLoad() {
   user_typed_before_load_ = false;
   waiting_for_new_page_ = true;
   add_page_vector_.clear();
   UnregisterForPaintNotifications();
 }
 
@@ skipping 63 matching lines @@
     }
   }
 }
 
 void InstantLoader::TabContentsDelegateImpl::RegisterForPaintNotifications(
     RenderWidgetHost* render_widget_host) {
   DCHECK(registered_render_widget_host_ == NULL);
   registered_render_widget_host_ = render_widget_host;
   Source<RenderWidgetHost> source =
       Source<RenderWidgetHost>(registered_render_widget_host_);
-  registrar_.Add(this, NotificationType::RENDER_WIDGET_HOST_DID_PAINT,
+  registrar_.Add(this, content::NOTIFICATION_RENDER_WIDGET_HOST_DID_PAINT,
                  source);
-  registrar_.Add(this, NotificationType::RENDER_WIDGET_HOST_DESTROYED,
+  registrar_.Add(this, content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
                  source);
 }
 
 void InstantLoader::TabContentsDelegateImpl::UnregisterForPaintNotifications() {
   if (registered_render_widget_host_) {
     Source<RenderWidgetHost> source =
         Source<RenderWidgetHost>(registered_render_widget_host_);
-    registrar_.Remove(this, NotificationType::RENDER_WIDGET_HOST_DID_PAINT,
+    registrar_.Remove(this, content::NOTIFICATION_RENDER_WIDGET_HOST_DID_PAINT,
                       source);
-    registrar_.Remove(this, NotificationType::RENDER_WIDGET_HOST_DESTROYED,
+    registrar_.Remove(this, content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
                       source);
     registered_render_widget_host_ = NULL;
   }
 }
 
 void InstantLoader::TabContentsDelegateImpl::Observe(
-    NotificationType type,
+    int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::FAIL_PROVISIONAL_LOAD_WITH_ERROR:
+  switch (type) {
+    case content::NOTIFICATION_FAIL_PROVISIONAL_LOAD_WITH_ERROR:
       if (Details<ProvisionalLoadDetails>(details)->url() == loader_->url_) {
         // This typically happens with downloads (which are disabled with
         // instant active). To ensure the download happens when the user presses
         // enter we set needs_reload_ to true, which triggers a reload.
         loader_->needs_reload_ = true;
       }
       break;
-    case NotificationType::RENDER_WIDGET_HOST_DID_PAINT:
+    case content::NOTIFICATION_RENDER_WIDGET_HOST_DID_PAINT:
       UnregisterForPaintNotifications();
       PreviewPainted();
       break;
-    case NotificationType::RENDER_WIDGET_HOST_DESTROYED:
+    case content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED:
       UnregisterForPaintNotifications();
       break;
-    case NotificationType::INTERSTITIAL_ATTACHED:
+    case content::NOTIFICATION_INTERSTITIAL_ATTACHED:
       PreviewPainted();
       break;
     default:
       NOTREACHED() << "Got a notification we didn't register for.";
   }
 }
 
 void InstantLoader::TabContentsDelegateImpl::NavigationStateChanged(
     const TabContents* source,
     unsigned changed_flags) {
@@ skipping 138 matching lines @@
 void InstantLoader::TabContentsDelegateImpl::OnInstantSupportDetermined(
     int32 page_id,
     bool result) {
   TabContents* source = loader_->preview_contents()->tab_contents();
   if (!source->controller().GetActiveEntry() ||
       page_id != source->controller().GetActiveEntry()->page_id())
     return;
 
   Details<const bool> details(&result);
   NotificationService::current()->Notify(
-      NotificationType::INSTANT_SUPPORT_DETERMINED,
+      chrome::NOTIFICATION_INSTANT_SUPPORT_DETERMINED,
       NotificationService::AllSources(),
       details);
 
   if (result)
     loader_->PageFinishedLoading();
   else
     loader_->PageDoesntSupportInstant(user_typed_before_load_);
 }
 
 void InstantLoader::TabContentsDelegateImpl
@@ skipping 175 matching lines @@
         preview_tab_contents_delegate_->SetLastHistoryURLAndPrune(url);
       }
       preview_tab_contents_delegate_->CommitHistory(template_url_id_ != 0);
     }
     if (preview_contents_->tab_contents()->GetRenderWidgetHostView()) {
 #if defined(OS_MACOSX)
       preview_contents_->tab_contents()->GetRenderWidgetHostView()->
           SetTakesFocusOnlyOnMouseDown(false);
       registrar_.Remove(
           this,
-          NotificationType::RENDER_VIEW_HOST_CHANGED,
+          chrome::RENDER_VIEW_HOST_CHANGED,
           Source<NavigationController>(&preview_contents_->controller()));
 #endif
     }
     preview_contents_->tab_contents()->set_delegate(NULL);
     preview_contents_->download_tab_helper()->set_delegate(NULL);
     ready_ = false;
   }
   update_bounds_timer_.Stop();
   return preview_contents_.release();
 }
@@ skipping 85 matching lines @@
     delegate_->InstantStatusChanged(this);
 }
 
 void InstantLoader::ShowPreview() {
   if (!ready_) {
     ready_ = true;
     delegate_->InstantStatusChanged(this);
   }
 }
 
-void InstantLoader::Observe(NotificationType type,
+void InstantLoader::Observe(int type,
                             const NotificationSource& source,
                             const NotificationDetails& details) {
 #if defined(OS_MACOSX)
-  if (type.value == NotificationType::RENDER_VIEW_HOST_CHANGED) {
+  if (type == chrome::RENDER_VIEW_HOST_CHANGED) {
     if (preview_contents_->tab_contents()->GetRenderWidgetHostView()) {
       preview_contents_->tab_contents()->GetRenderWidgetHostView()->
           SetTakesFocusOnlyOnMouseDown(true);
     }
     return;
   }
 #endif
-  if (type.value == NotificationType::NAV_ENTRY_COMMITTED) {
+  if (type == content::NOTIFICATION_NAV_ENTRY_COMMITTED) {
     content::LoadCommittedDetails* load_details =
         Details<content::LoadCommittedDetails>(details).ptr();
     if (load_details->is_main_frame) {
       if (load_details->http_status_code == kHostBlacklistStatusCode) {
         delegate_->AddToBlacklist(this, load_details->entry->url());
       } else {
         SetHTTPStatusOK(load_details->http_status_code == 200);
       }
     }
     return;
@@ skipping 68 matching lines @@
   // Make sure the new preview contents acts like the old one.
   SetupPreviewContents(old_tc);
 
   // Cleanup the old preview contents.
   old_tc->download_tab_helper()->set_delegate(NULL);
   old_tc->tab_contents()->set_delegate(NULL);
   old_tc->set_delegate(NULL);
 
 #if defined(OS_MACOSX)
   registrar_.Remove(this,
-                    NotificationType::RENDER_VIEW_HOST_CHANGED,
+                    content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
                     Source<NavigationController>(&old_tc->controller()));
 #endif
   registrar_.Remove(this,
-                 NotificationType::NAV_ENTRY_COMMITTED,
+                 content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                  Source<NavigationController>(&old_tc->controller()));
 
   // We prerendered so we should be ready to show. If we're ready, swap in
   // immediately, otherwise show the preview as normal.
   if (ready_)
     delegate_->SwappedTabContents(this);
   else
     ShowPreview();
 }
 
@@ skipping 16 matching lines @@
 #if defined(OS_MACOSX)
   // If |preview_contents_| does not currently have a RWHV, we will call
   // SetTakesFocusOnlyOnMouseDown() as a result of the
   // RENDER_VIEW_HOST_CHANGED notification.
   if (preview_contents_->tab_contents()->GetRenderWidgetHostView()) {
     preview_contents_->tab_contents()->GetRenderWidgetHostView()->
         SetTakesFocusOnlyOnMouseDown(true);
   }
   registrar_.Add(
       this,
-      NotificationType::RENDER_VIEW_HOST_CHANGED,
+      content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
       Source<NavigationController>(&preview_contents_->controller()));
 #endif
 
   registrar_.Add(
       this,
-      NotificationType::NAV_ENTRY_COMMITTED,
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED,
       Source<NavigationController>(&preview_contents_->controller()));
 
   gfx::Rect tab_bounds;
   tab_contents->view()->GetContainerBounds(&tab_bounds);
   preview_contents_->view()->SizeContents(tab_bounds.size());
 }
 
 void InstantLoader::CreatePreviewContents(TabContentsWrapper* tab_contents) {
   TabContents* new_contents =
       new TabContents(
@@ skipping 25 matching lines @@
   CommandLine* cl = CommandLine::ForCurrentProcess();
   if (cl->HasSwitch(switches::kInstantURL))
     instant_url = GURL(cl->GetSwitchValueASCII(switches::kInstantURL));
   preview_contents_->controller().LoadURL(instant_url, GURL(), transition_type);
   RenderViewHost* host = preview_contents_->render_view_host();
   host->Send(new ViewMsg_SearchBoxChange(
       host->routing_id(), user_text, verbatim, 0, 0));
   frame_load_observer_.reset(new FrameLoadObserver(
       this, preview_contents()->tab_contents(), user_text, verbatim));
 }