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

chrome/browser/ui/cocoa/profiles/profile_chooser_controller.mm

 // 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.
 
 #import <Cocoa/Cocoa.h>
 
 #import "chrome/browser/ui/cocoa/profiles/profile_chooser_controller.h"
 
 #include "base/mac/bundle_locations.h"
 #include "base/prefs/pref_service.h"
@@ skipping 260 matching lines @@
     DCHECK(oauth2_token_service);
     oauth2_token_service->RemoveObserver(this);
     token_observer_registered_ = false;
   }
 
   // OAuth2TokenService::Observer:
   virtual void OnRefreshTokenAvailable(const std::string& account_id) OVERRIDE {
     // Tokens can only be added by adding an account through the inline flow,
     // which is started from the account management view. Refresh it to show the
     // update.
-    BubbleViewMode viewMode = [controller_ viewMode];
-    if (viewMode == BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT ||
-        viewMode == BUBBLE_VIEW_MODE_GAIA_SIGNIN ||
-        viewMode == BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT) {
-      [controller_
-          initMenuContentsWithView:BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT];
+    profiles::BubbleViewMode viewMode = [controller_ viewMode];
+    if (viewMode == profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT ||
+        viewMode == profiles::BUBBLE_VIEW_MODE_GAIA_SIGNIN ||
+        viewMode == profiles::BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT) {
+      [controller_ initMenuContentsWithView:
+          profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT];
     }
   }
 
   virtual void OnRefreshTokenRevoked(const std::string& account_id) OVERRIDE {
     // Tokens can only be removed from the account management view. Refresh it
     // to show the update.
-    if ([controller_ viewMode] == BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT)
-      [controller_
-          initMenuContentsWithView:BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT];
+    if ([controller_ viewMode] == profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT)
+      [controller_ initMenuContentsWithView:
+          profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT];
   }
 
   // AvatarMenuObserver:
   virtual void OnAvatarMenuChanged(AvatarMenu* avatar_menu) OVERRIDE {
     // While the bubble is open, the avatar menu can only change from the
     // profile chooser view by modifying the current profile's photo or name.
-    [controller_ initMenuContentsWithView:BUBBLE_VIEW_MODE_PROFILE_CHOOSER];
+    [controller_
+        initMenuContentsWithView:profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER];
   }
 
   // content::NotificationObserver:
   virtual void Observe(
       int type,
       const content::NotificationSource& source,
       const content::NotificationDetails& details) OVERRIDE {
     DCHECK_EQ(chrome::NOTIFICATION_BROWSER_CLOSING, type);
     if (browser_ == content::Source<Browser>(source).ptr()) {
       RemoveTokenServiceObserver();
@@ skipping 343 matching lines @@
 
 @interface ProfileChooserController ()
 // Builds the profile chooser view.
 - (NSView*)buildProfileChooserView;
 
 // Builds a tutorial card with a title label using |titleMessageId|, a content
 // label using |contentMessageId|, and a bottom row with a right-aligned link
 // using |linkMessageId|, and a left aligned button using |buttonMessageId|.
 // On click, the link would execute |linkAction|, and the button would execute
 // |buttonAction|. It sets |tutorialMode_| to the given |mode|.
-- (NSView*)tutorialViewWithMode:(TutorialMode)mode
+- (NSView*)tutorialViewWithMode:(profiles::TutorialMode)mode
                    titleMessage:(int)titleMessageId
                  contentMessage:(int)contentMessageId
                     linkMessage:(int)linkMessageId
                   buttonMessage:(int)buttonMessageId
                      linkAction:(SEL)linkAction
                    buttonAction:(SEL)buttonAction;
 
 // Builds a a tutorial card for new profile management preview if needed. if
 // new profile management is not enabled yet, then it prompts the user to try
 // out the feature. Otherwise, it notifies the user that the feature has been
@@ skipping 51 matching lines @@
 
 // Creates an email account button with |title| and a remove icon. |tag|
 // indicates which account the button refers to.
 - (NSButton*)accountButtonWithRect:(NSRect)rect
                              title:(const std::string&)title
                                tag:(int)tag;
 
 @end
 
 @implementation ProfileChooserController
-- (BubbleViewMode) viewMode {
+- (profiles::BubbleViewMode) viewMode {
   return viewMode_;
 }
 
 - (IBAction)switchToProfile:(id)sender {
   // Check the event flags to see if a new window should be created.
   bool alwaysCreate = ui::WindowOpenDispositionFromNSEvent(
       [NSApp currentEvent]) == NEW_WINDOW;
   avatarMenu_->SwitchToProfile([sender tag], alwaysCreate,
                                ProfileMetrics::SWITCH_PROFILE_ICON);
 }
 
 - (IBAction)showUserManager:(id)sender {
   profiles::ShowUserManagerMaybeWithTutorial(browser_->profile());
 }
 
 - (IBAction)exitGuest:(id)sender {
   DCHECK(browser_->profile()->IsGuestSession());
   [self showUserManager:sender];
   profiles::CloseGuestProfileWindows();
 }
 
 - (IBAction)showAccountManagement:(id)sender {
-  [self initMenuContentsWithView:BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT];
+  [self initMenuContentsWithView:profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT];
 }
 
 - (IBAction)hideAccountManagement:(id)sender {
-  [self initMenuContentsWithView:BUBBLE_VIEW_MODE_PROFILE_CHOOSER];
+  [self initMenuContentsWithView:profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER];
 }
 
 - (IBAction)lockProfile:(id)sender {
   profiles::LockProfile(browser_->profile());
 }
 
 - (IBAction)showInlineSigninPage:(id)sender {
-  [self initMenuContentsWithView:BUBBLE_VIEW_MODE_GAIA_SIGNIN];
+  [self initMenuContentsWithView:profiles::BUBBLE_VIEW_MODE_GAIA_SIGNIN];
 }
 
 - (IBAction)showTabbedSigninPage:(id)sender {
   chrome::ShowBrowserSignin(browser_, signin::SOURCE_MENU);
 }
 
 - (IBAction)addAccount:(id)sender {
-  [self initMenuContentsWithView:BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT];
+  [self initMenuContentsWithView:profiles::BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT];
 }
 
 - (IBAction)navigateBackFromSigninPage:(id)sender {
   std::string primaryAccount = SigninManagerFactory::GetForProfile(
       browser_->profile())->GetAuthenticatedUsername();
   [self initMenuContentsWithView:primaryAccount.empty() ?
-      BUBBLE_VIEW_MODE_PROFILE_CHOOSER : BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT];
+      profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER :
+      profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT];
 }
 
 - (IBAction)showAccountRemovalView:(id)sender {
   DCHECK(!isGuestSession_);
 
   // Tag is either |kPrimaryProfileTag| for the primary account, or equal to the
   // index in |currentProfileAccounts_| for a secondary account.
   int tag = [sender tag];
   if (tag == kPrimaryProfileTag) {
     accountIdToRemove_ = SigninManagerFactory::GetForProfile(
         browser_->profile())->GetAuthenticatedUsername();
   } else {
     DCHECK(ContainsKey(currentProfileAccounts_, tag));
     accountIdToRemove_ = currentProfileAccounts_[tag];
   }
 
-  [self initMenuContentsWithView:BUBBLE_VIEW_MODE_ACCOUNT_REMOVAL];
+  [self initMenuContentsWithView:profiles::BUBBLE_VIEW_MODE_ACCOUNT_REMOVAL];
 }
 
 - (IBAction)removeAccount:(id)sender {
   DCHECK(!accountIdToRemove_.empty());
   ProfileOAuth2TokenServiceFactory::GetPlatformSpecificForProfile(
       browser_->profile())->RevokeCredentials(accountIdToRemove_);
   accountIdToRemove_.clear();
 
-  [self initMenuContentsWithView:BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT];
+  [self initMenuContentsWithView:profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT];
 }
 
 - (IBAction)openTutorialLearnMoreURL:(id)sender {
   // TODO(guohui): update |learnMoreUrl| once it is decided.
   const GURL learnMoreUrl("https://support.google.com/chrome/?hl=en#to");
   chrome::NavigateParams params(browser_->profile(), learnMoreUrl,
                                 content::PAGE_TRANSITION_LINK);
   params.disposition = NEW_FOREGROUND_TAB;
   chrome::Navigate(&params);
 }
 
 - (IBAction)enableNewProfileManagementPreview:(id)sender {
   profiles::EnableNewProfileManagementPreview();
 }
 
 - (IBAction)dismissTutorial:(id)sender {
   // 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);
-  [self initMenuContentsWithView:BUBBLE_VIEW_MODE_PROFILE_CHOOSER];
+  [self initMenuContentsWithView:profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER];
 }
 
 - (IBAction)showSendFeedbackTutorial:(id)sender {
-  tutorialMode_ = TUTORIAL_MODE_SEND_FEEDBACK;
-  [self initMenuContentsWithView:BUBBLE_VIEW_MODE_PROFILE_CHOOSER];
+  tutorialMode_ = profiles::TUTORIAL_MODE_SEND_FEEDBACK;
+  [self initMenuContentsWithView:profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER];
 }
 
 - (IBAction)showEndPreviewView:(id)sender {
-  [self initMenuContentsWithView:BUBBLE_VIEW_MODE_END_PREVIEW];
+  [self initMenuContentsWithView:profiles::BUBBLE_VIEW_MODE_END_PREVIEW];
 }
 
 - (IBAction)sendFeedback:(id)sender {
   chrome::OpenFeedbackDialog(browser_);
 }
 
 - (IBAction)endPreviewAndRelaunch:(id)sender {
   profiles::DisableNewProfileManagementPreview();
 }
 
 - (void)cleanUpEmbeddedViewContents {
   webContents_.reset();
 }
 
 - (id)initWithBrowser:(Browser*)browser
            anchoredAt:(NSPoint)point
-             withMode:(BubbleViewMode)mode {
+             withMode:(profiles::BubbleViewMode)mode {
   base::scoped_nsobject<InfoBubbleWindow> window([[InfoBubbleWindow alloc]
       initWithContentRect:ui::kWindowSizeDeterminedLater
                 styleMask:NSBorderlessWindowMask
                   backing:NSBackingStoreBuffered
                     defer:NO]);
 
   if ((self = [super initWithWindow:window
                        parentWindow:browser->window()->GetNativeWindow()
                          anchoredAt:point])) {
     browser_ = browser;
     viewMode_ = mode;
-    tutorialMode_ = TUTORIAL_MODE_NONE;
+    tutorialMode_ = profiles::TUTORIAL_MODE_NONE;
     observer_.reset(new ActiveProfileObserverBridge(self, browser_));
 
     avatarMenu_.reset(new AvatarMenu(
         &g_browser_process->profile_manager()->GetProfileInfoCache(),
         observer_.get(),
         browser_));
     avatarMenu_->RebuildMenu();
 
     // Guest profiles do not have a token service.
     isGuestSession_ = browser_->profile()->IsGuestSession();
 
     [[self bubble] setAlignment:info_bubble::kAlignRightEdgeToAnchorEdge];
     [[self bubble] setArrowLocation:info_bubble::kNoArrow];
     [[self bubble] setBackgroundColor:GetDialogBackgroundColor()];
     [self initMenuContentsWithView:viewMode_];
   }
 
   return self;
 }
 
-- (void)initMenuContentsWithView:(BubbleViewMode)viewToDisplay {
+- (void)initMenuContentsWithView:(profiles::BubbleViewMode)viewToDisplay {
   viewMode_ = viewToDisplay;
   NSView* contentView = [[self window] contentView];
   [contentView setSubviews:[NSArray array]];
   NSView* subView;
 
   switch (viewMode_) {
-    case BUBBLE_VIEW_MODE_GAIA_SIGNIN:
-    case BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT:
+    case profiles::BUBBLE_VIEW_MODE_GAIA_SIGNIN:
+    case profiles::BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT:
+    case profiles::BUBBLE_VIEW_MODE_GAIA_REAUTH:
       subView = [self buildGaiaEmbeddedView];
       break;
-    case BUBBLE_VIEW_MODE_ACCOUNT_REMOVAL:
+    case profiles::BUBBLE_VIEW_MODE_ACCOUNT_REMOVAL:
       subView = [self buildAccountRemovalView];
       break;
-    case BUBBLE_VIEW_MODE_END_PREVIEW:
+    case profiles::BUBBLE_VIEW_MODE_END_PREVIEW:
       subView = [self buildEndPreviewView];
       break;
-    case BUBBLE_VIEW_MODE_PROFILE_CHOOSER:
-    case BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT:
+    case profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER:
+    case profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT:
       subView = [self buildProfileChooserView];
+      break;
   }
 
   [contentView addSubview:subView];
   SetWindowSize([self window],
       NSMakeSize(NSWidth([subView frame]), NSHeight([subView frame])));
 }
 
 - (NSView*)buildProfileChooserView {
   base::scoped_nsobject<NSView> container(
       [[NSView alloc] initWithFrame:NSZeroRect]);
 
   NSView* tutorialView = nil;
   NSView* currentProfileView = nil;
   base::scoped_nsobject<NSMutableArray> otherProfiles(
       [[NSMutableArray alloc] init]);
   // Local and guest profiles cannot lock their profile.
   bool enableLock = false;
 
   // Loop over the profiles in reverse, so that they are sorted by their
   // y-coordinate, and separate them into active and "other" profiles.
   for (int i = avatarMenu_->GetNumberOfItems() - 1; i >= 0; --i) {
     const AvatarMenu::Item& item = avatarMenu_->GetItemAt(i);
     if (item.active) {
-      if (viewMode_ == BUBBLE_VIEW_MODE_PROFILE_CHOOSER)
+      if (viewMode_ == profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER)
         tutorialView = [self buildPreviewTutorialIfNeeded:item];
       currentProfileView = [self createCurrentProfileView:item];
       enableLock = item.signed_in;
     } else {
       [otherProfiles addObject:[self createOtherProfileView:i]];
     }
   }
   if (!currentProfileView)  // Guest windows don't have an active profile.
     currentProfileView = [self createGuestProfileView];
 
   // |yOffset| is the next position at which to draw in |container|
   // coordinates.
   CGFloat yOffset = 0;
 
   // Option buttons. Only available with the new profile management flag.
   if (switches::IsNewProfileManagement()) {
     NSRect rect = NSMakeRect(0, yOffset, kFixedMenuWidth, 0);
     NSView* optionsView = [self createOptionsViewWithRect:rect
                                                enableLock:enableLock];
     [container addSubview:optionsView];
     rect.origin.y = NSMaxY([optionsView frame]);
 
     NSBox* separator = [self separatorWithFrame:rect];
     [container addSubview:separator];
     yOffset = NSMaxY([separator frame]);
   }
 
-  if (viewMode_ == BUBBLE_VIEW_MODE_PROFILE_CHOOSER &&
+  if (viewMode_ == profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER &&
       switches::IsFastUserSwitching()) {
     // Other profiles switcher. The profiles have already been sorted
     // by their y-coordinate, so they can be added in the existing order.
     for (NSView *otherProfileView in otherProfiles.get()) {
       [otherProfileView setFrameOrigin:NSMakePoint(0, yOffset)];
       [container addSubview:otherProfileView];
       yOffset = NSMaxY([otherProfileView frame]);
 
       NSBox* separator =
           [self separatorWithFrame:NSMakeRect(0, yOffset, kFixedMenuWidth, 0)];
       [container addSubview:separator];
       yOffset = NSMaxY([separator frame]);
     }
-  } else if (viewMode_ == BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT) {
+  } else if (viewMode_ == profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT) {
     NSView* currentProfileAccountsView = [self createCurrentProfileAccountsView:
         NSMakeRect(0, yOffset, kFixedMenuWidth, 0)];
     [container addSubview:currentProfileAccountsView];
     yOffset = NSMaxY([currentProfileAccountsView frame]);
 
     NSBox* accountsSeparator = [self separatorWithFrame:
         NSMakeRect(0, yOffset, kFixedMenuWidth, 0)];
     [container addSubview:accountsSeparator];
     yOffset = NSMaxY([accountsSeparator frame]);
   }
 
   // Active profile card.
   if (currentProfileView) {
     yOffset += kVerticalSpacing;
     [currentProfileView setFrameOrigin:NSMakePoint(0, yOffset)];
     [container addSubview:currentProfileView];
     yOffset = NSMaxY([currentProfileView frame]) + kVerticalSpacing;
   }
 
   if (tutorialView) {
     [tutorialView setFrameOrigin:NSMakePoint(0, yOffset)];
     [container addSubview:tutorialView];
     yOffset = NSMaxY([tutorialView frame]);
   } else {
-    tutorialMode_ = TUTORIAL_MODE_NONE;
+    tutorialMode_ = profiles::TUTORIAL_MODE_NONE;
   }
 
   [container setFrameSize:NSMakeSize(kFixedMenuWidth, yOffset)];
   return container.autorelease();;
 }
 
 - (NSView*)buildPreviewTutorialIfNeeded:(const AvatarMenu::Item&)item {
   if (!switches::IsNewProfileManagement()) {
-    return [self tutorialViewWithMode:TUTORIAL_MODE_ENABLE_PREVIEW
+    return [self tutorialViewWithMode:profiles::TUTORIAL_MODE_ENABLE_PREVIEW
                          titleMessage:IDS_PROFILES_PREVIEW_TUTORIAL_TITLE
                        contentMessage:IDS_PROFILES_PREVIEW_TUTORIAL_CONTENT_TEXT
                           linkMessage:IDS_PROFILES_PROFILE_TUTORIAL_LEARN_MORE
                         buttonMessage:IDS_PROFILES_TUTORIAL_TRY_BUTTON
                            linkAction:@selector(openTutorialLearnMoreURL:)
                          buttonAction:
         @selector(enableNewProfileManagementPreview:)];
   }
 
   if (!switches::IsNewProfileManagementPreviewEnabled())
     return nil;
 
-  if (tutorialMode_ == TUTORIAL_MODE_SEND_FEEDBACK) {
-    return [self tutorialViewWithMode:TUTORIAL_MODE_SEND_FEEDBACK
+  if (tutorialMode_ == profiles::TUTORIAL_MODE_SEND_FEEDBACK) {
+    return [self tutorialViewWithMode:profiles::TUTORIAL_MODE_SEND_FEEDBACK
                          titleMessage:IDS_PROFILES_FEEDBACK_TUTORIAL_TITLE
                        contentMessage:
         IDS_PROFILES_FEEDBACK_TUTORIAL_CONTENT_TEXT
                           linkMessage:IDS_PROFILES_END_PREVIEW
                         buttonMessage:IDS_PROFILES_SEND_FEEDBACK_BUTTON
                            linkAction:@selector(showEndPreviewView:)
                          buttonAction:@selector(sendFeedback:)];
   }
 
   Profile* profile = browser_->profile();
   const int showCount = profile->GetPrefs()->GetInteger(
       prefs::kProfileAvatarTutorialShown);
   // Do not show the tutorial if user has dismissed it.
   if (showCount > kProfileAvatarTutorialShowMax)
     return nil;
 
-  if (tutorialMode_ != TUTORIAL_MODE_WELCOME) {
+  if (tutorialMode_ != profiles::TUTORIAL_MODE_WELCOME) {
     if (showCount == kProfileAvatarTutorialShowMax)
       return nil;
     profile->GetPrefs()->SetInteger(
         prefs::kProfileAvatarTutorialShown, showCount + 1);
   }
 
-  return [self tutorialViewWithMode:TUTORIAL_MODE_WELCOME
+  return [self tutorialViewWithMode:profiles::TUTORIAL_MODE_WELCOME
                        titleMessage:IDS_PROFILES_PREVIEW_ENABLED_TUTORIAL_TITLE
                      contentMessage:
       IDS_PROFILES_PREVIEW_ENABLED_TUTORIAL_CONTENT_TEXT
                         linkMessage:IDS_PROFILES_PROFILE_TUTORIAL_LEARN_MORE
                       buttonMessage:IDS_PROFILES_TUTORIAL_OK_BUTTON
                          linkAction:@selector(openTutorialLearnMoreURL:)
                        buttonAction:@selector(dismissTutorial:)];
 }
 
-- (NSView*)tutorialViewWithMode:(TutorialMode)mode
+- (NSView*)tutorialViewWithMode:(profiles::TutorialMode)mode
                    titleMessage:(int)titleMessageId
                  contentMessage:(int)contentMessageId
                     linkMessage:(int)linkMessageId
                   buttonMessage:(int)buttonMessageId
                      linkAction:(SEL)linkAction
                    buttonAction:(SEL)buttonAction {
   tutorialMode_ = mode;
 
   NSColor* tutorialBackgroundColor =
       gfx::SkColorToSRGBNSColor(profiles::kAvatarTutorialBackgroundColor);
@@ skipping 160 matching lines @@
   base::scoped_nsobject<NSView> container([[NSView alloc] initWithFrame:rect]);
 
   // Don't double-apply the left margin to the sub-views.
   rect.origin.x = 0;
 
   // The available links depend on the type of profile that is active.
   NSButton* link;
   if (item.signed_in) {
     if (switches::IsNewProfileManagement()) {
       NSString* linkTitle = l10n_util::GetNSString(
-          viewMode_ ==  BUBBLE_VIEW_MODE_PROFILE_CHOOSER ?
+          viewMode_ == profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER ?
               IDS_PROFILES_PROFILE_MANAGE_ACCOUNTS_BUTTON :
               IDS_PROFILES_PROFILE_HIDE_MANAGE_ACCOUNTS_BUTTON);
-      SEL linkSelector = (viewMode_ ==  BUBBLE_VIEW_MODE_PROFILE_CHOOSER) ?
+      SEL linkSelector =
+          (viewMode_ == profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER) ?
           @selector(showAccountManagement:) : @selector(hideAccountManagement:);
       link = [self linkButtonWithTitle:linkTitle
                            frameOrigin:rect.origin
                                 action:linkSelector];
     } else {
       link = [self linkButtonWithTitle:base::SysUTF16ToNSString(item.sync_state)
                            frameOrigin:rect.origin
                                 action:nil];
       [[link cell] setTextColor:[NSColor blackColor]];
     }
@@ skipping 173 matching lines @@
   [container setFrameSize:NSMakeSize(NSWidth([container frame]),
                                      NSMaxY([accountButton frame]))];
   return container.autorelease();
 }
 
 - (NSView*)buildGaiaEmbeddedView {
   base::scoped_nsobject<NSView> container(
       [[NSView alloc] initWithFrame:NSZeroRect]);
   CGFloat yOffset = 0;
 
-  bool addSecondaryAccount = viewMode_ == BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT;
+  bool addSecondaryAccount =
+      viewMode_ == profiles::BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT;
   signin::Source source = addSecondaryAccount ?
       signin::SOURCE_AVATAR_BUBBLE_ADD_ACCOUNT :
       signin::SOURCE_AVATAR_BUBBLE_SIGN_IN;
 
   webContents_.reset(content::WebContents::Create(
       content::WebContents::CreateParams(browser_->profile())));
   webContents_->GetController().LoadURL(
       signin::GetPromoURL(
           source, false /* auto_close */, true /* is_constrained */),
       content::Referrer(),
@@ skipping 231 matching lines @@
       IDR_CLOSE_1_P).ToNSImage()];
   [deleteButton setTarget:self];
   [deleteButton setAction:@selector(showAccountRemovalView:)];
   [deleteButton setTag:tag];
 
   [button addSubview:deleteButton];
   return button.autorelease();
 }
 
 @end