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

chrome/browser/ui/webui/ntp/new_tab_ui.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 "build/build_config.h"
 
 #include "chrome/browser/ui/webui/ntp/new_tab_ui.h"
 
 #include <set>
 
@@ skipping 22 matching lines @@
 #include "chrome/browser/ui/webui/ntp/favicon_webui_handler.h"
 #include "chrome/browser/ui/webui/ntp/foreign_session_handler.h"
 #include "chrome/browser/ui/webui/ntp/most_visited_handler.h"
 #include "chrome/browser/ui/webui/ntp/new_tab_page_sync_handler.h"
 #include "chrome/browser/ui/webui/ntp/ntp_login_handler.h"
 #include "chrome/browser/ui/webui/ntp/ntp_resource_cache.h"
 #include "chrome/browser/ui/webui/ntp/ntp_resource_cache_factory.h"
 #include "chrome/browser/ui/webui/ntp/shown_sections_handler.h"
 #include "chrome/browser/ui/webui/ntp/value_helper.h"
 #include "chrome/browser/ui/webui/theme_source.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/user_metrics.h"
 #include "content/common/notification_service.h"
 #include "grit/generated_resources.h"
@@ skipping 206 matching lines @@
   } 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.
     tab->set_new_tab_start_time(base::TimeTicks());
   } else {
     NOTREACHED();
   }
   NotificationService::current()->Notify(
-      NotificationType::METRIC_EVENT_DURATION,
+      chrome::NOTIFICATION_METRIC_EVENT_DURATION,
       Source<TabContents>(tab),
       Details<MetricEventDurationDetails>(&details));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // NewTabPageSetHomePageHandler
 
 // Sets the new tab page as home page when user clicks on "make this my home
 // page" link.
 class NewTabPageSetHomePageHandler : public WebUIMessageHandler {
@@ skipping 52 matching lines @@
 
 void NewTabPageClosePromoHandler::RegisterMessages() {
   web_ui_->RegisterMessageCallback("closePromo", NewCallback(
       this, &NewTabPageClosePromoHandler::HandleClosePromo));
 }
 
 void NewTabPageClosePromoHandler::HandleClosePromo(
     const ListValue* args) {
   web_ui_->GetProfile()->GetPrefs()->SetBoolean(prefs::kNTPPromoClosed, true);
   NotificationService* service = NotificationService::current();
-  service->Notify(NotificationType::PROMO_RESOURCE_STATE_CHANGED,
+  service->Notify(chrome::NOTIFICATION_PROMO_RESOURCE_STATE_CHANGED,
                   Source<NewTabPageClosePromoHandler>(this),
                   NotificationService::NoDetails());
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // NewTabUI
 
 NewTabUI::NewTabUI(TabContents* contents)
@@ skipping 49 matching lines @@
 
   // Initializing the CSS and HTML can require some CPU, so do it after
   // we've hooked up the most visited handler.  This allows the DB query
   // for the new tab thumbs to happen earlier.
   InitializeCSSCaches();
   NewTabHTMLSource* html_source =
       new NewTabHTMLSource(GetProfile()->GetOriginalProfile());
   contents->profile()->GetChromeURLDataManager()->AddDataSource(html_source);
 
   // Listen for theme installation.
-  registrar_.Add(this, NotificationType::BROWSER_THEME_CHANGED,
+  registrar_.Add(this, chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
                  Source<ThemeService>(
                      ThemeServiceFactory::GetForProfile(GetProfile())));
   // Listen for bookmark bar visibility changes.
-  registrar_.Add(this, NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED,
+  registrar_.Add(this,
+                 chrome::NOTIFICATION_BOOKMARK_BAR_VISIBILITY_PREF_CHANGED,
                  NotificationService::AllSources());
 }
 
 NewTabUI::~NewTabUI() {
 }
 
 // The timer callback.  If enough time has elapsed since the last paint
 // message, we say we're done painting; otherwise, we keep waiting.
 void NewTabUI::PaintTimeout() {
   // The amount of time there must be no painting for us to consider painting
   // finished.  Observed times are in the ~1200ms range on Windows.
   base::TimeTicks now = base::TimeTicks::Now();
   if ((now - last_paint_) >= base::TimeDelta::FromMilliseconds(kTimeoutMs)) {
     // Painting has quieted down.  Log this as the full time to run.
     base::TimeDelta load_time = last_paint_ - start_;
     int load_time_ms = static_cast<int>(load_time.InMilliseconds());
     NotificationService::current()->Notify(
-        NotificationType::INITIAL_NEW_TAB_UI_LOAD,
+        chrome::NOTIFICATION_INITIAL_NEW_TAB_UI_LOAD,
         NotificationService::AllSources(),
         Details<int>(&load_time_ms));
     UMA_HISTOGRAM_TIMES("NewTabUI load", load_time);
   } else {
     // Not enough quiet time has elapsed.
     // Some more paints must've occurred since we set the timeout.
     // Wait some more.
     timer_.Start(base::TimeDelta::FromMilliseconds(kTimeoutMs), this,
                  &NewTabUI::PaintTimeout);
   }
 }
 
 void NewTabUI::StartTimingPaint(RenderViewHost* render_view_host) {
   start_ = base::TimeTicks::Now();
   last_paint_ = start_;
-  registrar_.Add(this, NotificationType::RENDER_WIDGET_HOST_DID_PAINT,
+  registrar_.Add(this, content::NOTIFICATION_RENDER_WIDGET_HOST_DID_PAINT,
       Source<RenderWidgetHost>(render_view_host));
   timer_.Start(base::TimeDelta::FromMilliseconds(kTimeoutMs), this,
                &NewTabUI::PaintTimeout);
 
 }
 void NewTabUI::RenderViewCreated(RenderViewHost* render_view_host) {
   StartTimingPaint(render_view_host);
 }
 
 void NewTabUI::RenderViewReused(RenderViewHost* render_view_host) {
   StartTimingPaint(render_view_host);
 }
 
-void NewTabUI::Observe(NotificationType type,
+void NewTabUI::Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::BROWSER_THEME_CHANGED: {
+  switch (type) {
+    case chrome::NOTIFICATION_BROWSER_THEME_CHANGED: {
       InitializeCSSCaches();
       ListValue args;
       args.Append(Value::CreateStringValue(
           ThemeServiceFactory::GetForProfile(GetProfile())->HasCustomImage(
               IDR_THEME_NTP_ATTRIBUTION) ?
           "true" : "false"));
       CallJavascriptFunction("themeChanged", args);
       break;
     }
-    case NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED: {
+    case chrome::NOTIFICATION_BOOKMARK_BAR_VISIBILITY_PREF_CHANGED: {
       if (GetProfile()->GetPrefs()->IsManagedPreference(
               prefs::kEnableBookmarkBar)) {
         break;
       }
       if (GetProfile()->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar))
         CallJavascriptFunction("bookmarkBarAttached");
       else
         CallJavascriptFunction("bookmarkBarDetached");
       break;
     }
-    case NotificationType::RENDER_WIDGET_HOST_DID_PAINT: {
+    case content::NOTIFICATION_RENDER_WIDGET_HOST_DID_PAINT: {
       last_paint_ = base::TimeTicks::Now();
       break;
     }
     default:
-      CHECK(false) << "Unexpected notification: " << type.value;
+      CHECK(false) << "Unexpected notification: " << type;
   }
 }
 
 void NewTabUI::InitializeCSSCaches() {
   Profile* profile = GetProfile();
   ThemeSource* theme = new ThemeSource(profile);
   profile->GetChromeURLDataManager()->AddDataSource(theme);
 }
 
 // static
@@ skipping 165 matching lines @@
   SendResponse(request_id, html_bytes);
 }
 
 std::string NewTabUI::NewTabHTMLSource::GetMimeType(const std::string&) const {
   return "text/html";
 }
 
 bool NewTabUI::NewTabHTMLSource::ShouldReplaceExistingSource() const {
   return false;
 }