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

chrome/browser/sync/profile_sync_service.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/sync/profile_sync_service.h"
 
 #include <stddef.h>
 #include <map>
 #include <ostream>
 #include <set>
@@ skipping 20 matching lines @@
 #include "chrome/browser/sync/glue/change_processor.h"
 #include "chrome/browser/sync/glue/data_type_controller.h"
 #include "chrome/browser/sync/glue/data_type_manager.h"
 #include "chrome/browser/sync/glue/session_data_type_controller.h"
 #include "chrome/browser/sync/js_arg_list.h"
 #include "chrome/browser/sync/js_event_details.h"
 #include "chrome/browser/sync/profile_sync_factory.h"
 #include "chrome/browser/sync/signin_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/time_format.h"
 #include "chrome/common/url_constants.h"
 #include "content/common/notification_details.h"
 #include "content/common/notification_source.h"
-#include "content/common/notification_type.h"
 #include "grit/generated_resources.h"
 #include "net/base/cookie_monster.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using browser_sync::ChangeProcessor;
 using browser_sync::DataTypeController;
 using browser_sync::DataTypeManager;
 using browser_sync::SyncBackendHost;
 using sync_api::SyncCredentials;
 
@@ skipping 108 matching lines @@
   } else if (AreCredentialsAvailable()) {
     // If we have credentials and sync setup finished, autostart the backend.
     // Note that if we haven't finished setting up sync, backend bring up will
     // be done by the wizard.
     StartUp();
   }
 }
 
 void ProfileSyncService::RegisterAuthNotifications() {
   registrar_.Add(this,
-                 NotificationType::TOKEN_AVAILABLE,
+                 chrome::NOTIFICATION_TOKEN_AVAILABLE,
                  Source<TokenService>(profile_->GetTokenService()));
   registrar_.Add(this,
-                 NotificationType::TOKEN_LOADING_FINISHED,
+                 chrome::NOTIFICATION_TOKEN_LOADING_FINISHED,
                  Source<TokenService>(profile_->GetTokenService()));
   registrar_.Add(this,
-                 NotificationType::GOOGLE_SIGNIN_SUCCESSFUL,
+                 chrome::NOTIFICATION_GOOGLE_SIGNIN_SUCCESSFUL,
                  Source<Profile>(profile_));
   registrar_.Add(this,
-                 NotificationType::GOOGLE_SIGNIN_FAILED,
+                 chrome::NOTIFICATION_GOOGLE_SIGNIN_FAILED,
                  Source<Profile>(profile_));
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableSyncOAuth)) {
     registrar_.Add(this,
-                   NotificationType::COOKIE_CHANGED,
+                   chrome::NOTIFICATION_COOKIE_CHANGED,
                    Source<Profile>(profile_));
   }
 }
 
 void ProfileSyncService::RegisterDataTypeController(
     DataTypeController* data_type_controller) {
   DCHECK_EQ(data_type_controllers_.count(data_type_controller->type()), 0U);
   data_type_controllers_[data_type_controller->type()] =
       data_type_controller;
 }
@@ skipping 200 matching lines @@
 }
 
 void ProfileSyncService::Shutdown(bool sync_disabled) {
   // Stop all data type controllers, if needed.
   if (data_type_manager_.get()) {
     if (data_type_manager_->state() != DataTypeManager::STOPPED) {
       data_type_manager_->Stop();
     }
 
     registrar_.Remove(this,
-                      NotificationType::SYNC_CONFIGURE_START,
+                      chrome::NOTIFICATION_SYNC_CONFIGURE_START,
                       Source<DataTypeManager>(data_type_manager_.get()));
     registrar_.Remove(this,
-                      NotificationType::SYNC_CONFIGURE_DONE,
+                      chrome::NOTIFICATION_SYNC_CONFIGURE_DONE,
                       Source<DataTypeManager>(data_type_manager_.get()));
     data_type_manager_.reset();
   }
 
   // Shutdown the migrator before the backend to ensure it doesn't pull a null
   // snapshot.
   migrator_.reset();
   js_event_handlers_.RemoveBackend();
 
   // Move aside the backend so nobody else tries to use it while we are
@@ skipping 660 matching lines @@
   // knows what it's doing.
   return backend_.get();
 }
 
 void ProfileSyncService::ConfigureDataTypeManager() {
   if (!data_type_manager_.get()) {
     data_type_manager_.reset(
         factory_->CreateDataTypeManager(backend_.get(),
                                         data_type_controllers_));
     registrar_.Add(this,
-                   NotificationType::SYNC_CONFIGURE_START,
+                   chrome::NOTIFICATION_SYNC_CONFIGURE_START,
                    Source<DataTypeManager>(data_type_manager_.get()));
     registrar_.Add(this,
-                   NotificationType::SYNC_CONFIGURE_DONE,
+                   chrome::NOTIFICATION_SYNC_CONFIGURE_DONE,
                    Source<DataTypeManager>(data_type_manager_.get()));
 
     // We create the migrator at the same time.
     migrator_.reset(
         new browser_sync::BackendMigrator(this, data_type_manager_.get()));
   }
 
   syncable::ModelTypeSet types;
   GetPreferredDataTypes(&types);
   if (IsPassphraseRequiredForDecryption()) {
@@ skipping 121 matching lines @@
     DCHECK(encrypted_types->count(syncable::PASSWORDS));
   } else {
     // Either we are in an unrecoverable error or the sync is not yet done
     // initializing. In either case just return the password type. During
     // sync initialization the UI might need to know what our encrypted
     // types are.
     (*encrypted_types).insert(syncable::PASSWORDS);
   }
 }
 
-void ProfileSyncService::Observe(NotificationType type,
+void ProfileSyncService::Observe(int type,
                                  const NotificationSource& source,
                                  const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::SYNC_CONFIGURE_START: {
+  switch (type) {
+    case chrome::NOTIFICATION_SYNC_CONFIGURE_START: {
       NotifyObservers();
       // TODO(sync): Maybe toast?
       break;
     }
-    case NotificationType::SYNC_CONFIGURE_DONE: {
+    case chrome::NOTIFICATION_SYNC_CONFIGURE_DONE: {
       DataTypeManager::ConfigureResultWithErrorLocation* result_with_location =
           Details<DataTypeManager::ConfigureResultWithErrorLocation>(
               details).ptr();
 
       DataTypeManager::ConfigureResult result = result_with_location->result;
       VLOG(1) << "PSS SYNC_CONFIGURE_DONE called with result: " << result;
       if (result == DataTypeManager::ABORTED &&
           expect_sync_configuration_aborted_) {
         VLOG(0) << "ProfileSyncService::Observe Sync Configure aborted";
         expect_sync_configuration_aborted_ = false;
@@ skipping 32 matching lines @@
       // this is the point where it is safe to switch from config-mode to
       // normal operation.
       backend_->StartSyncingWithServer();
 
       if (!pending_types_for_encryption_.empty()) {
         EncryptDataTypes(pending_types_for_encryption_);
         pending_types_for_encryption_.clear();
       }
       break;
     }
-    case NotificationType::PREF_CHANGED: {
+    case chrome::NOTIFICATION_PREF_CHANGED: {
       std::string* pref_name = Details<std::string>(details).ptr();
       if (*pref_name == prefs::kSyncManaged) {
         NotifyObservers();
         if (*pref_sync_managed_) {
           DisableForUser();
         } else if (HasSyncSetupCompleted() && AreCredentialsAvailable()) {
           StartUp();
         }
       }
       break;
     }
-    case NotificationType::GOOGLE_SIGNIN_SUCCESSFUL: {
+    case chrome::NOTIFICATION_GOOGLE_SIGNIN_SUCCESSFUL: {
       const GoogleServiceSigninSuccessDetails* successful =
           (Details<const GoogleServiceSigninSuccessDetails>(details).ptr());
       // We pass 'false' to SetPassphrase to denote that this is an implicit
       // request and shouldn't override an explicit one.  Thus, we either
       // update the implicit passphrase (idempotent if the passphrase didn't
       // actually change), or the user has an explicit passphrase set so this
       // becomes a no-op.
       SetPassphrase(successful->password, false, true);
       break;
     }
-    case NotificationType::GOOGLE_SIGNIN_FAILED: {
+    case chrome::NOTIFICATION_GOOGLE_SIGNIN_FAILED: {
       GoogleServiceAuthError error =
           *(Details<const GoogleServiceAuthError>(details).ptr());
       UpdateAuthErrorState(error);
       break;
     }
-    case NotificationType::TOKEN_AVAILABLE: {
+    case chrome::NOTIFICATION_TOKEN_AVAILABLE: {
       if (AreCredentialsAvailable()) {
         if (backend_initialized_) {
           backend_->UpdateCredentials(GetCredentials());
         }
 
         if (!profile_->GetPrefs()->GetBoolean(prefs::kSyncSuppressStart))
           StartUp();
       }
       break;
     }
-    case NotificationType::TOKEN_LOADING_FINISHED: {
+    case chrome::NOTIFICATION_TOKEN_LOADING_FINISHED: {
       // If not in Chrome OS, and we have a username without tokens,
       // the user will need to signin again, so sign out.
       if (cros_user_.empty() &&
           !signin_->GetUsername().empty() &&
           !AreCredentialsAvailable()) {
         DisableForUser();
       }
       break;
     }
-    case NotificationType::COOKIE_CHANGED: {
+    case chrome::NOTIFICATION_COOKIE_CHANGED: {
       OnCookieChanged(Source<Profile>(source).ptr(),
                       Details<ChromeCookieDetails>(details).ptr());
       break;
     }
     default: {
       NOTREACHED();
     }
   }
 }
 
@@ skipping 34 matching lines @@
   // is initialized, all enabled data types are consistent with one
   // another, and no unrecoverable error has transpired.
   if (unrecoverable_error_detected_)
     return false;
 
   if (!data_type_manager_.get())
     return false;
 
   return data_type_manager_->state() == DataTypeManager::CONFIGURED;
 }