Move profile_chooser enums to a constant place for mac and win.

chrome/browser/ui/views/profiles/profile_chooser_view.cc

 // Copyright 2014 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/ui/views/profiles/profile_chooser_view.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
@@ skipping 395 matching lines @@
 };
 
 // ProfileChooserView ---------------------------------------------------------
 
 // static
 ProfileChooserView* ProfileChooserView::profile_bubble_ = NULL;
 bool ProfileChooserView::close_on_deactivate_for_testing_ = true;
 
 // static
 void ProfileChooserView::ShowBubble(
-    BubbleViewMode view_mode,
+    profiles::BubbleViewMode view_mode,
     views::View* anchor_view,
     views::BubbleBorder::Arrow arrow,
     views::BubbleBorder::BubbleAlignment border_alignment,
     const gfx::Rect& anchor_rect,
     Browser* browser) {
   if (IsShowing())
     return;
 
   profile_bubble_ = new ProfileChooserView(anchor_view, arrow, anchor_rect,
                                            browser, view_mode);
@@ skipping 12 matching lines @@
 // static
 void ProfileChooserView::Hide() {
   if (IsShowing())
     profile_bubble_->GetWidget()->Close();
 }
 
 ProfileChooserView::ProfileChooserView(views::View* anchor_view,
                                        views::BubbleBorder::Arrow arrow,
                                        const gfx::Rect& anchor_rect,
                                        Browser* browser,
-                                       BubbleViewMode view_mode)
+                                       profiles::BubbleViewMode view_mode)
     : BubbleDelegateView(anchor_view, arrow),
       browser_(browser),
       view_mode_(view_mode),
-      tutorial_mode_(TUTORIAL_MODE_NONE) {
+      tutorial_mode_(profiles::TUTORIAL_MODE_NONE) {
   // Reset the default margins inherited from the BubbleDelegateView.
   set_margins(gfx::Insets());
 
   ResetView();
 
   avatar_menu_.reset(new AvatarMenu(
       &g_browser_process->profile_manager()->GetProfileInfoCache(),
       this,
       browser_));
   avatar_menu_->RebuildMenu();
@@ skipping 26 matching lines @@
   tutorial_end_preview_link_ = NULL;
   tutorial_send_feedback_button_ = NULL;
   end_preview_and_relaunch_button_ = NULL;
   end_preview_cancel_button_ = NULL;
   remove_account_button_ = NULL;
   account_removal_cancel_button_ = NULL;
   gaia_signin_cancel_button_ = NULL;
   open_other_profile_indexes_map_.clear();
   delete_account_button_map_.clear();
   reauth_account_button_map_.clear();
-  tutorial_mode_ = TUTORIAL_MODE_NONE;
+  tutorial_mode_ = profiles::TUTORIAL_MODE_NONE;
 }
 
 void ProfileChooserView::Init() {
   // If view mode is PROFILE_CHOOSER but there is an auth error, force
   // ACCOUNT_MANAGEMENT mode.
-  if (view_mode_ == BUBBLE_VIEW_MODE_PROFILE_CHOOSER &&
+  if (view_mode_ == profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER &&
       HasAuthError(browser_->profile())) {
-    view_mode_ = BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT;
+    view_mode_ = profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT;
   }
 
   ShowView(view_mode_, avatar_menu_.get());
 }
 
 void ProfileChooserView::OnAvatarMenuChanged(
     AvatarMenu* avatar_menu) {
   // Refresh the view with the new menu. We can't just update the local copy
   // as this may have been triggered by a sign out action, in which case
   // the view is being destroyed.
-  ShowView(BUBBLE_VIEW_MODE_PROFILE_CHOOSER, avatar_menu);
+  ShowView(profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER, avatar_menu);
 }
 
 void ProfileChooserView::OnRefreshTokenAvailable(
     const std::string& account_id) {
   // Refresh the account management view when a new account is added to the
   // profile.
-  if (view_mode_ == BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT ||
-      view_mode_ == BUBBLE_VIEW_MODE_GAIA_SIGNIN ||
-      view_mode_ == BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT ||
-      view_mode_ == BUBBLE_VIEW_MODE_GAIA_REAUTH) {
-    ShowView(BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT, avatar_menu_.get());
+  if (view_mode_ == profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT ||
+      view_mode_ == profiles::BUBBLE_VIEW_MODE_GAIA_SIGNIN ||
+      view_mode_ == profiles::BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT ||
+      view_mode_ == profiles::BUBBLE_VIEW_MODE_GAIA_REAUTH) {
+    ShowView(profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT, avatar_menu_.get());
   }
 }
 
 void ProfileChooserView::OnRefreshTokenRevoked(const std::string& account_id) {
   // Refresh the account management view when an account is removed from the
   // profile.
-  if (view_mode_ == BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT)
-    ShowView(BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT, avatar_menu_.get());
+  if (view_mode_ == profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT)
+    ShowView(profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT, avatar_menu_.get());
 }
 
-void ProfileChooserView::ShowView(BubbleViewMode view_to_display,
+void ProfileChooserView::ShowView(profiles::BubbleViewMode view_to_display,
                                   AvatarMenu* avatar_menu) {
   // The account management view should only be displayed if the active profile
   // is signed in.
-  if (view_to_display == BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT) {
+  if (view_to_display == profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT) {
     const AvatarMenu::Item& active_item = avatar_menu->GetItemAt(
         avatar_menu->GetActiveProfileIndex());
     DCHECK(active_item.signed_in);
   }
 
   // Records the last tutorial mode.
-  TutorialMode last_tutorial_mode = tutorial_mode_;
+  profiles::TutorialMode last_tutorial_mode = tutorial_mode_;
   ResetView();
   RemoveAllChildViews(true);
   view_mode_ = view_to_display;
 
   views::GridLayout* layout;
   views::View* sub_view;
   switch (view_mode_) {
-    case BUBBLE_VIEW_MODE_GAIA_SIGNIN:
-    case BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT:
-    case BUBBLE_VIEW_MODE_GAIA_REAUTH:
+    case profiles::BUBBLE_VIEW_MODE_GAIA_SIGNIN:
+    case profiles::BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT:
+    case profiles::BUBBLE_VIEW_MODE_GAIA_REAUTH:
       layout = CreateSingleColumnLayout(this, kFixedGaiaViewWidth);
       sub_view = CreateGaiaSigninView();
       break;
-    case BUBBLE_VIEW_MODE_ACCOUNT_REMOVAL:
+    case profiles::BUBBLE_VIEW_MODE_ACCOUNT_REMOVAL:
       layout = CreateSingleColumnLayout(this, kFixedAccountRemovalViewWidth);
       sub_view = CreateAccountRemovalView();
       break;
-    case BUBBLE_VIEW_MODE_END_PREVIEW:
+    case profiles::BUBBLE_VIEW_MODE_END_PREVIEW:
       layout = CreateSingleColumnLayout(this, kFixedEndPreviewViewWidth);
       sub_view = CreateEndPreviewView();
       break;
     default:
       layout = CreateSingleColumnLayout(this, kFixedMenuWidth);
       sub_view = CreateProfileChooserView(avatar_menu, last_tutorial_mode);
   }
   sub_view->set_background(views::Background::CreateSolidBackground(
       GetNativeTheme()->GetSystemColor(
           ui::NativeTheme::kColorId_DialogBackground)));
@@ skipping 28 matching lines @@
   } else if (sender == tutorial_ok_button_) {
     // If the user manually dismissed the tutorial, never show it again by
     // setting the number of times shown to the maximum plus 1, so that later we
     // could distinguish between the dismiss case and the case when the tutorial
     // is indeed shown for the maximum number of times.
     browser_->profile()->GetPrefs()->SetInteger(
         prefs::kProfileAvatarTutorialShown, kProfileAvatarTutorialShowMax + 1);
 
     ProfileMetrics::LogProfileUpgradeEnrollment(
         ProfileMetrics::PROFILE_ENROLLMENT_CLOSE_WELCOME_CARD);
-    ShowView(BUBBLE_VIEW_MODE_PROFILE_CHOOSER, avatar_menu_.get());
+    ShowView(profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER, avatar_menu_.get());
   } else if (sender == tutorial_enable_new_profile_management_button_) {
     ProfileMetrics::LogProfileUpgradeEnrollment(
         ProfileMetrics::PROFILE_ENROLLMENT_ACCEPT_NEW_PROFILE_MGMT);
     profiles::EnableNewProfileManagementPreview();
   } else if (sender == remove_account_button_) {
     RemoveAccount();
   } else if (sender == account_removal_cancel_button_) {
     account_id_to_remove_.clear();
-    ShowView(BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT, avatar_menu_.get());
+    ShowView(profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT, avatar_menu_.get());
   } else if (sender == gaia_signin_cancel_button_) {
     std::string primary_account =
         SigninManagerFactory::GetForProfile(browser_->profile())->
         GetAuthenticatedUsername();
-    ShowView(primary_account.empty() ? BUBBLE_VIEW_MODE_PROFILE_CHOOSER :
-                                       BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT,
+    ShowView(primary_account.empty() ?
+                 profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER :
+                 profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT,
              avatar_menu_.get());
   } else if (sender == question_mark_button_) {
-    tutorial_mode_ = TUTORIAL_MODE_SEND_FEEDBACK;
-    ShowView(BUBBLE_VIEW_MODE_PROFILE_CHOOSER, avatar_menu_.get());
+    tutorial_mode_ = profiles::TUTORIAL_MODE_SEND_FEEDBACK;
+    ShowView(profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER, avatar_menu_.get());
   } else if (sender == tutorial_send_feedback_button_) {
     ProfileMetrics::LogProfileUpgradeEnrollment(
         ProfileMetrics::PROFILE_ENROLLMENT_SEND_FEEDBACK);
     chrome::OpenFeedbackDialog(browser_);
   } else if (sender == end_preview_and_relaunch_button_) {
     ProfileMetrics::LogProfileUpgradeEnrollment(
         ProfileMetrics::PROFILE_ENROLLMENT_DISABLE_NEW_PROFILE_MGMT);
     profiles::DisableNewProfileManagementPreview();
   } else if (sender == end_preview_cancel_button_) {
-    tutorial_mode_ = TUTORIAL_MODE_SEND_FEEDBACK;
-    ShowView(BUBBLE_VIEW_MODE_PROFILE_CHOOSER, avatar_menu_.get());
+    tutorial_mode_ = profiles::TUTORIAL_MODE_SEND_FEEDBACK;
+    ShowView(profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER, avatar_menu_.get());
   } else if (current_profile_photo_ &&
              sender == current_profile_photo_->change_photo_button()) {
     avatar_menu_->EditProfile(avatar_menu_->GetActiveProfileIndex());
   } else if (sender == signin_current_profile_link_) {
     // Only show the inline signin if the new UI flag is flipped. Otherwise,
     // use the tab signin page.
     if (switches::IsNewProfileManagement())
-      ShowView(BUBBLE_VIEW_MODE_GAIA_SIGNIN, avatar_menu_.get());
+      ShowView(profiles::BUBBLE_VIEW_MODE_GAIA_SIGNIN, avatar_menu_.get());
     else
       chrome::ShowBrowserSignin(browser_, signin::SOURCE_MENU);
   } else {
     // Either one of the "other profiles", or one of the profile accounts
     // buttons was pressed.
     ButtonIndexes::const_iterator profile_match =
         open_other_profile_indexes_map_.find(sender);
     if (profile_match != open_other_profile_indexes_map_.end()) {
       avatar_menu_->SwitchToProfile(
           profile_match->second,
           ui::DispositionFromEventFlags(event.flags()) == NEW_WINDOW,
           ProfileMetrics::SWITCH_PROFILE_ICON);
     } else {
       // This was a profile accounts button.
       AccountButtonIndexes::const_iterator account_match =
           delete_account_button_map_.find(sender);
       if (account_match != delete_account_button_map_.end()) {
         account_id_to_remove_ = account_match->second;
-        ShowView(BUBBLE_VIEW_MODE_ACCOUNT_REMOVAL, avatar_menu_.get());
+        ShowView(profiles::BUBBLE_VIEW_MODE_ACCOUNT_REMOVAL,
+            avatar_menu_.get());
       } else {
         account_match = reauth_account_button_map_.find(sender);
         DCHECK(account_match != reauth_account_button_map_.end());
-        ShowView(BUBBLE_VIEW_MODE_GAIA_REAUTH, avatar_menu_.get());
+        ShowView(profiles::BUBBLE_VIEW_MODE_GAIA_REAUTH, avatar_menu_.get());
       }
     }
   }
 }
 
 void ProfileChooserView::RemoveAccount() {
   DCHECK(!account_id_to_remove_.empty());
   MutableProfileOAuth2TokenService* oauth2_token_service =
       ProfileOAuth2TokenServiceFactory::GetPlatformSpecificForProfile(
       browser_->profile());
   if (oauth2_token_service)
     oauth2_token_service->RevokeCredentials(account_id_to_remove_);
   account_id_to_remove_.clear();
 
-  ShowView(BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT, avatar_menu_.get());
+  ShowView(profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT, avatar_menu_.get());
 }
 
 void ProfileChooserView::LinkClicked(views::Link* sender, int event_flags) {
   if (sender == manage_accounts_link_) {
     // This link can either mean show/hide the account management view,
     // depending on which view it is displayed. ShowView() will DCHECK if
     // the account management view is displayed for non signed-in users.
     ShowView(
-        view_mode_ == BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT ?
-            BUBBLE_VIEW_MODE_PROFILE_CHOOSER :
-            BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT,
+        view_mode_ == profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT ?
+            profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER :
+            profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT,
         avatar_menu_.get());
   } else if (sender == add_account_link_) {
-    ShowView(BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT, avatar_menu_.get());
+    ShowView(profiles::BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT, avatar_menu_.get());
   } else if (sender == tutorial_learn_more_link_) {
     ProfileMetrics::LogProfileUpgradeEnrollment(
         ProfileMetrics::PROFILE_ENROLLMENT_LAUNCH_LEARN_MORE);
     // TODO(guohui): update |learn_more_url| once it is decided.
     const GURL lear_more_url("https://support.google.com/chrome/?hl=en#to");
     chrome::NavigateParams params(
         browser_->profile(),
         lear_more_url,
         content::PAGE_TRANSITION_LINK);
     params.disposition = NEW_FOREGROUND_TAB;
     chrome::Navigate(&params);
   } else {
     DCHECK(sender == tutorial_end_preview_link_);
-    ShowView(BUBBLE_VIEW_MODE_END_PREVIEW, avatar_menu_.get());
+    ShowView(profiles::BUBBLE_VIEW_MODE_END_PREVIEW, avatar_menu_.get());
   }
 }
 
 void ProfileChooserView::StyledLabelLinkClicked(
     const gfx::Range& range, int event_flags) {
   chrome::ShowSettings(browser_);
 }
 
 bool ProfileChooserView::HandleKeyEvent(views::Textfield* sender,
                                         const ui::KeyEvent& key_event) {
@@ skipping 19 matching lines @@
 
     profiles::UpdateProfileName(profile, new_profile_name);
     current_profile_name_->ShowReadOnlyView();
     return true;
   }
   return false;
 }
 
 views::View* ProfileChooserView::CreateProfileChooserView(
     AvatarMenu* avatar_menu,
-    TutorialMode last_tutorial_mode) {
+    profiles::TutorialMode last_tutorial_mode) {
   // TODO(guohui, noms): the view should be customized based on whether new
   // profile management preview is enabled or not.
 
   views::View* view = new views::View();
   views::GridLayout* layout = CreateSingleColumnLayout(view, kFixedMenuWidth);
   // Separate items into active and alternatives.
   Indexes other_profiles;
   views::View* tutorial_view = NULL;
   views::View* current_profile_view = NULL;
   views::View* current_profile_accounts = NULL;
   views::View* option_buttons_view = NULL;
   bool is_new_profile_management = switches::IsNewProfileManagement();
   for (size_t i = 0; i < avatar_menu->GetNumberOfItems(); ++i) {
     const AvatarMenu::Item& item = avatar_menu->GetItemAt(i);
     if (item.active) {
       option_buttons_view = CreateOptionsView(item.signed_in);
       current_profile_view = CreateCurrentProfileView(item, false);
-      if (view_mode_ == BUBBLE_VIEW_MODE_PROFILE_CHOOSER) {
+      if (view_mode_ == profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER) {
         if (is_new_profile_management) {
-          tutorial_view = last_tutorial_mode == TUTORIAL_MODE_SEND_FEEDBACK ?
+          tutorial_view =
+              last_tutorial_mode == profiles::TUTORIAL_MODE_SEND_FEEDBACK ?
               CreateSendPreviewFeedbackView() :
               CreatePreviewEnabledTutorialView(
-                  item, last_tutorial_mode == TUTORIAL_MODE_PREVIEW_ENABLED);
+                  item, last_tutorial_mode == profiles::TUTORIAL_MODE_WELCOME);
         } else {
           tutorial_view = CreateNewProfileManagementPreviewView();
         }
       } else {
         current_profile_accounts = CreateCurrentProfileAccountsView(item);
       }
     } else {
       other_profiles.push_back(i);
     }
   }
@@ skipping 11 matching lines @@
 
   if (!current_profile_view) {
     // Guest windows don't have an active profile.
     current_profile_view = CreateGuestProfileView();
     option_buttons_view = CreateOptionsView(false);
   }
 
   layout->StartRow(1, 0);
   layout->AddView(current_profile_view);
 
-  if (view_mode_ == BUBBLE_VIEW_MODE_PROFILE_CHOOSER) {
+  if (view_mode_ == profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER) {
     layout->StartRow(1, 0);
     if (switches::IsFastUserSwitching())
       layout->AddView(CreateOtherProfilesView(other_profiles));
   } else {
     DCHECK(current_profile_accounts);
     layout->StartRow(0, 0);
     layout->AddView(new views::Separator(views::Separator::HORIZONTAL));
     layout->StartRow(1, 0);
     layout->AddView(current_profile_accounts);
   }
@@ skipping 24 matching lines @@
     return NULL;
 
   if (!tutorial_shown) {
     if (show_count == kProfileAvatarTutorialShowMax)
       return NULL;
     profile->GetPrefs()->SetInteger(
         prefs::kProfileAvatarTutorialShown, show_count + 1);
   }
 
   return CreateTutorialView(
-      TUTORIAL_MODE_PREVIEW_ENABLED,
+      profiles::TUTORIAL_MODE_WELCOME,
       l10n_util::GetStringUTF16(IDS_PROFILES_PREVIEW_ENABLED_TUTORIAL_TITLE),
       l10n_util::GetStringUTF16(
           IDS_PROFILES_PREVIEW_ENABLED_TUTORIAL_CONTENT_TEXT),
       l10n_util::GetStringUTF16(IDS_PROFILES_PROFILE_TUTORIAL_LEARN_MORE),
       l10n_util::GetStringUTF16(IDS_PROFILES_TUTORIAL_OK_BUTTON),
       &tutorial_learn_more_link_,
       &tutorial_ok_button_);
 }
 
 views::View* ProfileChooserView::CreateSendPreviewFeedbackView() {
   return CreateTutorialView(
-      TUTORIAL_MODE_SEND_FEEDBACK,
+      profiles::TUTORIAL_MODE_SEND_FEEDBACK,
       l10n_util::GetStringUTF16(IDS_PROFILES_FEEDBACK_TUTORIAL_TITLE),
       l10n_util::GetStringUTF16(
           IDS_PROFILES_FEEDBACK_TUTORIAL_CONTENT_TEXT),
       l10n_util::GetStringUTF16(IDS_PROFILES_END_PREVIEW),
       l10n_util::GetStringUTF16(IDS_PROFILES_SEND_FEEDBACK_BUTTON),
       &tutorial_end_preview_link_,
       &tutorial_send_feedback_button_);
 }
 
 views::View* ProfileChooserView::CreateTutorialView(
-    TutorialMode tutorial_mode,
+    profiles::TutorialMode tutorial_mode,
     const base::string16& title_text,
     const base::string16& content_text,
     const base::string16& link_text,
     const base::string16& button_text,
     views::Link** link,
     views::LabelButton** button) {
   tutorial_mode_ = tutorial_mode;
 
   views::View* view = new views::View();
   view->set_background(views::Background::CreateSolidBackground(
@@ skipping 125 matching lines @@
   layout->AddView(current_profile_name_);
 
   if (is_guest)
     return view;
 
   // The available links depend on the type of profile that is active.
   if (avatar_item.signed_in) {
     layout->StartRow(1, 0);
     if (switches::IsNewProfileManagement()) {
       base::string16 link_title = l10n_util::GetStringUTF16(
-          view_mode_ ==  BUBBLE_VIEW_MODE_PROFILE_CHOOSER ?
+          view_mode_ == profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER ?
               IDS_PROFILES_PROFILE_MANAGE_ACCOUNTS_BUTTON :
               IDS_PROFILES_PROFILE_HIDE_MANAGE_ACCOUNTS_BUTTON);
       manage_accounts_link_ = CreateLink(link_title, this);
       manage_accounts_link_->SetHorizontalAlignment(gfx::ALIGN_CENTER);
       layout->AddView(manage_accounts_link_);
     } else {
       views::Label* email_label = new views::Label(avatar_item.sync_state);
       email_label->SetHorizontalAlignment(gfx::ALIGN_CENTER);
       layout->AddView(email_label);
     }
@@ skipping 211 matching lines @@
     email_button->AddChildView(reauth_button);
     reauth_account_button_map_[reauth_button] = account;
   }
 }
 
 views::View* ProfileChooserView::CreateGaiaSigninView() {
   GURL url;
   int message_id;
 
   switch (view_mode_) {
-    case BUBBLE_VIEW_MODE_GAIA_SIGNIN:
+    case profiles::BUBBLE_VIEW_MODE_GAIA_SIGNIN:
       url = signin::GetPromoURL(signin::SOURCE_AVATAR_BUBBLE_SIGN_IN,
                                 false /* auto_close */,
                                 true /* is_constrained */);
       message_id = IDS_PROFILES_GAIA_SIGNIN_TITLE;
       break;
-    case BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT:
+    case profiles::BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT:
       url = signin::GetPromoURL(signin::SOURCE_AVATAR_BUBBLE_ADD_ACCOUNT,
                                 false /* auto_close */,
                                 true /* is_constrained */);
       message_id = IDS_PROFILES_GAIA_ADD_ACCOUNT_TITLE;
       break;
-    case BUBBLE_VIEW_MODE_GAIA_REAUTH: {
+    case profiles::BUBBLE_VIEW_MODE_GAIA_REAUTH: {
       DCHECK(HasAuthError(browser_->profile()));
       url = signin::GetReauthURL(browser_->profile(),
                                  GetAuthErrorUsername(browser_->profile()));
       message_id = IDS_PROFILES_GAIA_REAUTH_TITLE;
       break;
     }
     default:
       NOTREACHED() << "Called with invalid mode=" << view_mode_;
       return NULL;
   }
@@ skipping 67 matching lines @@
   }
 
   TitleCard* title_card = new TitleCard(IDS_PROFILES_ACCOUNT_REMOVAL_TITLE,
       this, &account_removal_cancel_button_);
   return TitleCard::AddPaddedTitleCard(view, title_card,
       kFixedAccountRemovalViewWidth);
 }
 
 views::View* ProfileChooserView::CreateNewProfileManagementPreviewView() {
   return CreateTutorialView(
-      TUTORIAL_MODE_ENABLE_PREVIEW,
+      profiles::TUTORIAL_MODE_ENABLE_PREVIEW,
       l10n_util::GetStringUTF16(IDS_PROFILES_PREVIEW_TUTORIAL_TITLE),
       l10n_util::GetStringUTF16(IDS_PROFILES_PREVIEW_TUTORIAL_CONTENT_TEXT),
       l10n_util::GetStringUTF16(IDS_PROFILES_PROFILE_TUTORIAL_LEARN_MORE),
       l10n_util::GetStringUTF16(IDS_PROFILES_TUTORIAL_TRY_BUTTON),
       &tutorial_learn_more_link_,
       &tutorial_enable_new_profile_management_button_);
 }
 
 views::View* ProfileChooserView::CreateEndPreviewView() {
   views::View* view = new views::View();
@@ skipping 24 matching lines @@
   layout->StartRowWithPadding(
       1, 0, 0, views::kUnrelatedControlVerticalSpacing);
   layout->AddView(end_preview_and_relaunch_button_);
 
   TitleCard* title_card = new TitleCard(
       IDS_PROFILES_END_PREVIEW, this, &end_preview_cancel_button_);
   return TitleCard::AddPaddedTitleCard(
       view, title_card, kFixedAccountRemovalViewWidth);
 }