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

chrome/browser/chromeos/login/user_manager.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/chromeos/login/user_manager.h"
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 11 matching lines @@
 #include "chrome/browser/chromeos/cros/cryptohome_library.h"
 #include "chrome/browser/chromeos/input_method/input_method_manager.h"
 #include "chrome/browser/chromeos/login/default_user_images.h"
 #include "chrome/browser/chromeos/login/login_display.h"
 #include "chrome/browser/chromeos/login/ownership_service.h"
 #include "chrome/browser/chromeos/user_cros_settings_provider.h"
 #include "chrome/browser/chromeos/wm_ipc.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/browser/browser_thread.h"
 #include "content/common/notification_service.h"
-#include "content/common/notification_type.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/codec/png_codec.h"
 
 namespace chromeos {
 
 namespace {
 
 // A vector pref of the users who have logged into the device.
 const char kLoggedInUsers[] = "LoggedInUsers";
 // A dictionary that maps usernames to file paths to their images.
@@ skipping 49 matching lines @@
     LOG(ERROR) << "Failed to remove user image.";
     return;
   }
 }
 
 // Updates current user ownership on UI thread.
 void UpdateOwnership(bool is_owner) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   g_user_manager.Get().set_current_user_is_owner(is_owner);
-  NotificationService::current()->Notify(NotificationType::OWNERSHIP_CHECKED,
-                                         NotificationService::AllSources(),
-                                         NotificationService::NoDetails());
+  NotificationService::current()->Notify(
+      chrome::NOTIFICATION_OWNERSHIP_CHECKED,
+      NotificationService::AllSources(),
+      NotificationService::NoDetails());
   if (is_owner) {
     // Also update cached value.
     UserCrosSettingsProvider::UpdateCachedOwner(
       g_user_manager.Get().logged_in_user().email());
   }
 }
 
 // Checks current user's ownership on file thread.
 void CheckOwnership() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
@@ skipping 411 matching lines @@
   DVLOG(1) << "Loaded image for " << username;
   user_images_[username] = image;
   User user;
   user.set_email(username);
   user.set_image(image);
   if (logged_in_user_.email() == username)
     logged_in_user_.set_image(image);
   if (should_save_image)
     SaveUserImage(username, image);
   NotificationService::current()->Notify(
-      NotificationType::LOGIN_USER_IMAGE_CHANGED,
+      chrome::NOTIFICATION_LOGIN_USER_IMAGE_CHANGED,
       Source<UserManager>(this),
       Details<const User>(&user));
 }
 
 bool UserManager::IsLoggedInAsGuest() const {
   return logged_in_user().email() == kGuestUser;
 }
 
 // Private constructor and destructor. Do nothing.
 UserManager::UserManager()
     : ALLOW_THIS_IN_INITIALIZER_LIST(image_loader_(new UserImageLoader(this))),
       current_user_is_owner_(false),
       current_user_is_new_(false),
       user_is_logged_in_(false) {
-  registrar_.Add(this, NotificationType::OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED,
+  registrar_.Add(this, chrome::NOTIFICATION_OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED,
       NotificationService::AllSources());
 }
 
 UserManager::~UserManager() {
   image_loader_->set_delegate(NULL);
 }
 
 FilePath UserManager::GetImagePathForUser(const std::string& username) {
   std::string filename = username + ".png";
   FilePath user_data_dir;
@@ skipping 29 matching lines @@
   CrosLibrary::Get()->GetCryptohomeLibrary()->Pkcs11GetTpmTokenInfo(
       &local_token_name, &local_user_pin);
   if (token_name)
     *token_name = local_token_name;
   if (user_pin)
     *user_pin = local_user_pin;
 }
 
 void UserManager::NotifyOnLogin() {
   NotificationService::current()->Notify(
-      NotificationType::LOGIN_USER_CHANGED,
+      chrome::NOTIFICATION_LOGIN_USER_CHANGED,
       Source<UserManager>(this),
       Details<const User>(&logged_in_user_));
 
   chromeos::input_method::InputMethodManager::GetInstance()->
       SetDeferImeStartup(false);
   // Shut down the IME so that it will reload the user's settings.
   chromeos::input_method::InputMethodManager::GetInstance()->
       StopInputMethodDaemon();
   // Let the window manager know that we're logged in now.
   WmIpc::instance()->SetLoggedInProperty(true);
   // Ensure we've opened the real user's key/certificate database.
   crypto::OpenPersistentNSSDB();
 
   // Only load the Opencryptoki library into NSS if we have this switch.
   // TODO(gspencer): Remove this switch once cryptohomed work is finished:
   // http://crosbug.com/12295 and http://crosbug.com/12304
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kLoadOpencryptoki)) {
     crypto::EnableTPMTokenForNSS(new RealTPMTokenInfoDelegate());
   }
 
   // Schedules current user ownership check on file thread.
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
       NewRunnableFunction(&CheckOwnership));
 }
 
-void UserManager::Observe(NotificationType type,
+void UserManager::Observe(int type,
                           const NotificationSource& source,
                           const NotificationDetails& details) {
-  if (type == NotificationType::OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED) {
+  if (type == chrome::NOTIFICATION_OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED) {
     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
         NewRunnableFunction(&CheckOwnership));
   }
 }
 
 bool UserManager::current_user_is_owner() const {
   base::AutoLock lk(current_user_is_owner_lock_);
   return current_user_is_owner_;
 }
 
 void UserManager::set_current_user_is_owner(bool current_user_is_owner) {
   base::AutoLock lk(current_user_is_owner_lock_);
   current_user_is_owner_ = current_user_is_owner;
 }
 
 }  // namespace chromeos