// 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"
#include "base/strings/sys_string_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/chrome_notification_types.h"
#include "chrome/browser/lifetime/application_lifetime.h"
#include "chrome/browser/profiles/avatar_menu.h"
#include "chrome/browser/profiles/avatar_menu_observer.h"
#include "chrome/browser/profiles/profile_avatar_icon_util.h"
#include "chrome/browser/profiles/profile_info_cache.h"
#include "chrome/browser/profiles/profile_manager.h"
#include "chrome/browser/profiles/profile_metrics.h"
#include "chrome/browser/profiles/profile_window.h"
#include "chrome/browser/profiles/profiles_state.h"
#include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
#include "chrome/browser/signin/signin_header_helper.h"
#include "chrome/browser/signin/signin_manager_factory.h"
#include "chrome/browser/signin/signin_promo.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/browser/ui/browser_commands.h"
#include "chrome/browser/ui/browser_dialogs.h"
#include "chrome/browser/ui/browser_window.h"
#include "chrome/browser/ui/chrome_pages.h"
#include "chrome/browser/ui/chrome_style.h"
#import "chrome/browser/ui/cocoa/hyperlink_text_view.h"
#import "chrome/browser/ui/cocoa/info_bubble_view.h"
#import "chrome/browser/ui/cocoa/info_bubble_window.h"
#import "chrome/browser/ui/cocoa/profiles/user_manager_mac.h"
#include "chrome/browser/ui/singleton_tabs.h"
#include "chrome/common/pref_names.h"
#include "chrome/common/url_constants.h"
#include "components/signin/core/common/profile_management_switches.h"
#include "components/signin/core/browser/mutable_profile_oauth2_token_service.h"
#include "components/signin/core/browser/profile_oauth2_token_service.h"
#include "components/signin/core/browser/signin_manager.h"
#include "content/public/browser/notification_service.h"
#include "content/public/browser/web_contents.h"
#include "google_apis/gaia/oauth2_token_service.h"
#include "grit/chromium_strings.h"
#include "grit/generated_resources.h"
#include "grit/theme_resources.h"
#include "skia/ext/skia_utils_mac.h"
#import "third_party/google_toolbox_for_mac/src/AppKit/GTMUILocalizerAndLayoutTweaker.h"
#import "ui/base/cocoa/cocoa_base_utils.h"
#import "ui/base/cocoa/controls/blue_label_button.h"
#import "ui/base/cocoa/controls/hyperlink_button_cell.h"
#import "ui/base/cocoa/hover_image_button.h"
#include "ui/base/cocoa/window_size_constants.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/l10n/l10n_util_mac.h"
#include "ui/base/resource/resource_bundle.h"
#include "ui/gfx/image/image.h"
#include "ui/gfx/text_elider.h"
#include "ui/native_theme/native_theme.h"

namespace {

// Constants taken from the Windows/Views implementation at:
// chrome/browser/ui/views/profile_chooser_view.cc
const int kLargeImageSide = 88;
const int kSmallImageSide = 32;
const CGFloat kFixedMenuWidth = 250;

const CGFloat kVerticalSpacing = 16.0;
const CGFloat kSmallVerticalSpacing = 10.0;
const CGFloat kHorizontalSpacing = 16.0;
const CGFloat kTitleFontSize = 15.0;
const CGFloat kTextFontSize = 12.0;
const CGFloat kProfileButtonHeight = 30;
const int kBezelThickness = 3;  // Width of the bezel on an NSButton.
const int kImageTitleSpacing = 10;
const int kBlueButtonHeight = 30;

// Fixed size for embedded sign in pages as defined in Gaia.
const CGFloat kFixedGaiaViewWidth = 360;
const CGFloat kFixedGaiaViewHeight = 400;

// Fixed size for the account removal view.
const CGFloat kFixedAccountRemovalViewWidth = 280;
// Fixed size for the end-preview view.
const int kFixedEndPreviewViewWidth = 280;

// Maximum number of times to show the welcome tutorial in the profile avatar
// bubble.
const int kProfileAvatarTutorialShowMax = 1;

// The tag number for the primary account.
const int kPrimaryProfileTag = -1;

gfx::Image CreateProfileImage(const gfx::Image& icon, int imageSize) {
  return profiles::GetSizedAvatarIcon(
      icon, true /* image is a square */, imageSize, imageSize);
}

// Updates the window size and position.
void SetWindowSize(NSWindow* window, NSSize size) {
  NSRect frame = [window frame];
  frame.origin.x += frame.size.width - size.width;
  frame.origin.y += frame.size.height - size.height;
  frame.size = size;
  [window setFrame:frame display:YES];
}

NSString* ElideEmail(const std::string& email, CGFloat width) {
  const base::string16 elidedEmail = gfx::ElideText(
      base::UTF8ToUTF16(email), gfx::FontList(), width, gfx::ELIDE_EMAIL);
  return base::SysUTF16ToNSString(elidedEmail);
}

// Builds a label with the given |title| anchored at |frame_origin|. Sets the
// text color and background color to the given colors if not null.
NSTextField* BuildLabel(NSString* title,
                        NSPoint frame_origin,
                        NSColor* background_color,
                        NSColor* text_color) {
  base::scoped_nsobject<NSTextField> label(
      [[NSTextField alloc] initWithFrame:NSZeroRect]);
  [label setStringValue:title];
  [label setEditable:NO];
  [label setAlignment:NSLeftTextAlignment];
  [label setBezeled:NO];
  [label setFont:[NSFont labelFontOfSize:kTextFontSize]];
  [label setFrameOrigin:frame_origin];
  [label sizeToFit];

  if (background_color)
    [[label cell] setBackgroundColor:background_color];
  if (text_color)
    [[label cell] setTextColor:text_color];

  return label.autorelease();
}

// Builds an NSTextView that has the contents set to the specified |message|,
// with a non-underlined |link| inserted at |link_offset|. The view is anchored
// at the specified |frame_origin| and has a fixed |frame_width|.
NSTextView* BuildFixedWidthTextViewWithLink(
    id<NSTextViewDelegate> delegate,
    NSString* message,
    NSString* link,
    int link_offset,
    NSPoint frame_origin,
    CGFloat frame_width) {
  base::scoped_nsobject<HyperlinkTextView> text_view(
      [[HyperlinkTextView alloc] initWithFrame:NSZeroRect]);
  NSColor* link_color = gfx::SkColorToCalibratedNSColor(
      chrome_style::GetLinkColor());
  // Adds a padding row at the bottom, because |boundingRectWithSize| below cuts
  // off the last row sometimes.
  [text_view setMessageAndLink:[NSString stringWithFormat:@"%@\n", message]
                      withLink:link
                      atOffset:link_offset
                          font:[NSFont labelFontOfSize:kTextFontSize]
                  messageColor:[NSColor blackColor]
                     linkColor:link_color];

  // Removes the underlining from the link.
  [text_view setLinkTextAttributes:nil];
  NSTextStorage* text_storage = [text_view textStorage];
  NSRange link_range = NSMakeRange(link_offset, [link length]);
  [text_storage addAttribute:NSUnderlineStyleAttributeName
                       value:[NSNumber numberWithInt:NSUnderlineStyleNone]
                       range:link_range];

  NSRect frame = [[text_view attributedString]
      boundingRectWithSize:NSMakeSize(frame_width, 0)
                   options:NSStringDrawingUsesLineFragmentOrigin];
  frame.origin = frame_origin;
  [text_view setFrame:frame];
  [text_view setDelegate:delegate];
  return text_view.autorelease();
}

// Returns the native dialog background color.
NSColor* GetDialogBackgroundColor() {
  return gfx::SkColorToCalibratedNSColor(
      ui::NativeTheme::instance()->GetSystemColor(
          ui::NativeTheme::kColorId_DialogBackground));
}

// Builds a title card with one back button right aligned and one label center
// aligned.
NSView* BuildTitleCard(NSRect frame_rect,
                       int message_id,
                       id back_button_target,
                       SEL back_button_action) {
  base::scoped_nsobject<NSView> container(
      [[NSView alloc] initWithFrame:frame_rect]);

  base::scoped_nsobject<HoverImageButton> button(
      [[HoverImageButton alloc] initWithFrame:frame_rect]);
  [button setBordered:NO];
  ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
  [button setDefaultImage:rb->GetNativeImageNamed(IDR_BACK).ToNSImage()];
  [button setHoverImage:rb->GetNativeImageNamed(IDR_BACK_H).ToNSImage()];
  [button setPressedImage:rb->GetNativeImageNamed(IDR_BACK_P).ToNSImage()];
  [button setTarget:back_button_target];
  [button setAction:back_button_action];
  [button setFrameSize:NSMakeSize(kProfileButtonHeight, kProfileButtonHeight)];
  [button setFrameOrigin:NSMakePoint(kHorizontalSpacing, 0)];

  NSTextField* title_label =
      BuildLabel(l10n_util::GetNSString(message_id), NSZeroPoint,
                 GetDialogBackgroundColor(), nil /* text_color */);
  [title_label setAlignment:NSCenterTextAlignment];
  [title_label setFont:[NSFont labelFontOfSize:kTitleFontSize]];
  [title_label sizeToFit];
  CGFloat x_offset = (frame_rect.size.width - NSWidth([title_label frame])) / 2;
  CGFloat y_offset =
      (NSHeight([button frame]) - NSHeight([title_label frame])) / 2;
  [title_label setFrameOrigin:NSMakePoint(x_offset, y_offset)];

  [container addSubview:button];
  [container addSubview:title_label];
  CGFloat height = std::max(NSMaxY([title_label frame]),
                            NSMaxY([button frame])) + kSmallVerticalSpacing;
  [container setFrameSize:NSMakeSize(NSWidth([container frame]), height)];

  return container.autorelease();
}

bool HasAuthError(Profile* profile) {
  const SigninErrorController* error_controller =
      profiles::GetSigninErrorController(profile);
  return error_controller && error_controller->HasError();
}

}  // namespace

// Class that listens to changes to the OAuth2Tokens for the active profile,
// changes to the avatar menu model or browser close notifications.
class ActiveProfileObserverBridge : public AvatarMenuObserver,
                                    public content::NotificationObserver,
                                    public OAuth2TokenService::Observer {
 public:
  ActiveProfileObserverBridge(ProfileChooserController* controller,
                              Browser* browser)
      : controller_(controller),
        browser_(browser),
        token_observer_registered_(false) {
    registrar_.Add(this, chrome::NOTIFICATION_BROWSER_CLOSING,
                   content::NotificationService::AllSources());
    if (!browser_->profile()->IsGuestSession())
      AddTokenServiceObserver();
  }

  virtual ~ActiveProfileObserverBridge() {
    RemoveTokenServiceObserver();
  }

 private:
  void AddTokenServiceObserver() {
    ProfileOAuth2TokenService* oauth2_token_service =
        ProfileOAuth2TokenServiceFactory::GetForProfile(browser_->profile());
    DCHECK(oauth2_token_service);
    oauth2_token_service->AddObserver(this);
    token_observer_registered_ = true;
  }

  void RemoveTokenServiceObserver() {
    if (!token_observer_registered_)
      return;
    DCHECK(browser_->profile());
    ProfileOAuth2TokenService* oauth2_token_service =
        ProfileOAuth2TokenServiceFactory::GetForProfile(browser_->profile());
    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.
    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 ||
        viewMode == profiles::BUBBLE_VIEW_MODE_GAIA_REAUTH) {
      [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] == 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: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();
      // Clean up the bubble's WebContents (used by the Gaia embedded view), to
      // make sure the guest profile doesn't have any dangling host renderers.
      // This can happen if Chrome is quit using Command-Q while the bubble is
      // still open, which won't give the bubble a chance to be closed and
      // clean up the WebContents itself.
      [controller_ cleanUpEmbeddedViewContents];
    }
  }

  ProfileChooserController* controller_;  // Weak; owns this.
  Browser* browser_;  // Weak.
  content::NotificationRegistrar registrar_;

  // The observer can be removed both when closing the browser, and by just
  // closing the avatar bubble. However, in the case of closing the browser,
  // the avatar bubble will also be closed afterwards, resulting in a second
  // attempt to remove the observer. This ensures the observer is only
  // removed once.
  bool token_observer_registered_;

  DISALLOW_COPY_AND_ASSIGN(ActiveProfileObserverBridge);
};

// Custom button cell that adds a left padding before the button image, and
// a custom spacing between the button image and title.
@interface CustomPaddingImageButtonCell : NSButtonCell {
 @private
  // Padding added to the left margin of the button.
  int leftMarginSpacing_;
  // Spacing between the cell image and title.
  int imageTitleSpacing_;
}

- (id)initWithLeftMarginSpacing:(int)leftMarginSpacing
              imageTitleSpacing:(int)imageTitleSpacing;
@end

@implementation CustomPaddingImageButtonCell
- (id)initWithLeftMarginSpacing:(int)leftMarginSpacing
              imageTitleSpacing:(int)imageTitleSpacing {
  if ((self = [super init])) {
    leftMarginSpacing_ = leftMarginSpacing;
    imageTitleSpacing_ = imageTitleSpacing;
  }
  return self;
}

- (NSRect)drawTitle:(NSAttributedString*)title
          withFrame:(NSRect)frame
             inView:(NSView*)controlView {
  NSRect marginRect;
  NSDivideRect(frame, &marginRect, &frame, leftMarginSpacing_, NSMinXEdge);

  // The title frame origin isn't aware of the left margin spacing added
  // in -drawImage, so it must be added when drawing the title as well.
  if ([self imagePosition] == NSImageLeft)
    NSDivideRect(frame, &marginRect, &frame, imageTitleSpacing_, NSMinXEdge);

  return [super drawTitle:title withFrame:frame inView:controlView];
}

- (void)drawImage:(NSImage*)image
        withFrame:(NSRect)frame
           inView:(NSView*)controlView {
  if ([self imagePosition] == NSImageLeft)
    frame.origin.x = leftMarginSpacing_;
  [super drawImage:image withFrame:frame inView:controlView];
}

- (NSSize)cellSize {
  NSSize buttonSize = [super cellSize];
  buttonSize.width += leftMarginSpacing_;
  if ([self imagePosition] == NSImageLeft)
    buttonSize.width += imageTitleSpacing_;
  return buttonSize;
}

@end

// A custom button that has a transparent backround.
@interface TransparentBackgroundButton : NSButton
@end

@implementation TransparentBackgroundButton
- (id)initWithFrame:(NSRect)frameRect {
  if ((self = [super initWithFrame:frameRect])) {
    [self setBordered:NO];
    [self setFont:[NSFont labelFontOfSize:kTextFontSize]];
    [self setButtonType:NSMomentaryChangeButton];
  }
  return self;
}

- (void)drawRect:(NSRect)dirtyRect {
  NSColor* backgroundColor = [NSColor colorWithCalibratedWhite:1 alpha:0.6f];
  [backgroundColor setFill];
  NSRectFillUsingOperation(dirtyRect, NSCompositeSourceAtop);
  [super drawRect:dirtyRect];
}
@end

// A custom image control that shows a "Change" button when moused over.
@interface EditableProfilePhoto : NSImageView {
 @private
  AvatarMenu* avatarMenu_;  // Weak; Owned by ProfileChooserController.
  base::scoped_nsobject<TransparentBackgroundButton> changePhotoButton_;
  // Used to display the "Change" button on hover.
  ui::ScopedCrTrackingArea trackingArea_;
  ProfileChooserController* controller_;
}

- (id)initWithFrame:(NSRect)frameRect
         avatarMenu:(AvatarMenu*)avatarMenu
        profileIcon:(const gfx::Image&)profileIcon
     editingAllowed:(BOOL)editingAllowed
     withController:(ProfileChooserController*)controller;

// Called when the "Change" button is clicked.
- (void)editPhoto:(id)sender;

// When hovering over the profile photo, show the "Change" button.
- (void)mouseEntered:(NSEvent*)event;

// When hovering away from the profile photo, hide the "Change" button.
- (void)mouseExited:(NSEvent*)event;
@end

@interface EditableProfilePhoto (Private)
// Create the "Change" avatar photo button.
- (TransparentBackgroundButton*)changePhotoButtonWithRect:(NSRect)rect;
@end

@implementation EditableProfilePhoto
- (id)initWithFrame:(NSRect)frameRect
         avatarMenu:(AvatarMenu*)avatarMenu
        profileIcon:(const gfx::Image&)profileIcon
     editingAllowed:(BOOL)editingAllowed
     withController:(ProfileChooserController*)controller {
  if ((self = [super initWithFrame:frameRect])) {
    avatarMenu_ = avatarMenu;
    controller_ = controller;
    [self setImage:CreateProfileImage(
        profileIcon, kLargeImageSide).ToNSImage()];

    // Add a tracking area so that we can show/hide the button when hovering.
    trackingArea_.reset([[CrTrackingArea alloc]
        initWithRect:[self bounds]
             options:NSTrackingMouseEnteredAndExited | NSTrackingActiveAlways
               owner:self
            userInfo:nil]);
    [self addTrackingArea:trackingArea_.get()];

    NSRect bounds = NSMakeRect(0, 0, kLargeImageSide, kLargeImageSide);
    if (editingAllowed) {
      changePhotoButton_.reset([self changePhotoButtonWithRect:bounds]);
      [self addSubview:changePhotoButton_];

      // Hide the button until the image is hovered over.
      [changePhotoButton_ setHidden:YES];
    }
  }
  return self;
}

- (void)drawRect:(NSRect)dirtyRect {
  NSRect bounds = [self bounds];

  // Display the profile picture as a circle.
  NSBezierPath* path = [NSBezierPath bezierPathWithOvalInRect:bounds];
  [path addClip];
  [self.image drawAtPoint:bounds.origin
                 fromRect:bounds
                operation:NSCompositeSourceOver
                 fraction:1.0];

}

- (void)editPhoto:(id)sender {
  avatarMenu_->EditProfile(avatarMenu_->GetActiveProfileIndex());
  [controller_
      postActionPerformed:ProfileMetrics::PROFILE_DESKTOP_MENU_EDIT_IMAGE];
}

- (void)mouseEntered:(NSEvent*)event {
  [changePhotoButton_ setHidden:NO];
}

- (void)mouseExited:(NSEvent*)event {
  [changePhotoButton_ setHidden:YES];
}

- (TransparentBackgroundButton*)changePhotoButtonWithRect:(NSRect)rect {
  TransparentBackgroundButton* button =
      [[TransparentBackgroundButton alloc] initWithFrame:rect];
  [button setImage:ui::ResourceBundle::GetSharedInstance().GetNativeImageNamed(
      IDR_ICON_PROFILES_EDIT_CAMERA).AsNSImage()];
  [button setImagePosition:NSImageOnly];
  [button setTarget:self];
  [button setAction:@selector(editPhoto:)];
  return button;
}
@end

// A custom text control that turns into a textfield for editing when clicked.
@interface EditableProfileNameButton : HoverImageButton {
 @private
  base::scoped_nsobject<NSTextField> profileNameTextField_;
  Profile* profile_;  // Weak.
  ProfileChooserController* controller_;
}

- (id)initWithFrame:(NSRect)frameRect
            profile:(Profile*)profile
        profileName:(NSString*)profileName
     editingAllowed:(BOOL)editingAllowed
     withController:(ProfileChooserController*)controller;

// Called when the button is clicked.
- (void)showEditableView:(id)sender;

// Called when enter is pressed in the text field.
- (void)saveProfileName:(id)sender;

@end

@implementation EditableProfileNameButton
- (id)initWithFrame:(NSRect)frameRect
            profile:(Profile*)profile
        profileName:(NSString*)profileName
     editingAllowed:(BOOL)editingAllowed
     withController:(ProfileChooserController*)controller {
  if ((self = [super initWithFrame:frameRect])) {
    profile_ = profile;
    controller_ = controller;

    if (editingAllowed) {
      // Show an "edit" pencil icon when hovering over. In the default state,
      // we need to create an empty placeholder of the correct size, so that
      // the text doesn't jump around when the hovered icon appears.
      ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
      NSImage* hoverImage = rb->GetNativeImageNamed(
          IDR_ICON_PROFILES_EDIT_HOVER).AsNSImage();

      // In order to center the button title, we need to add a left padding of
      // the same width as the pencil icon.
      base::scoped_nsobject<CustomPaddingImageButtonCell> cell(
          [[CustomPaddingImageButtonCell alloc]
              initWithLeftMarginSpacing:[hoverImage size].width
                      imageTitleSpacing:0]);
      [self setCell:cell.get()];

      NSImage* placeholder = [[NSImage alloc] initWithSize:[hoverImage size]];
      [self setDefaultImage:placeholder];
      [self setHoverImage:hoverImage];
      [self setAlternateImage:
          rb->GetNativeImageNamed(IDR_ICON_PROFILES_EDIT_PRESSED).AsNSImage()];
      [self setImagePosition:NSImageRight];
      [self setTarget:self];
      [self setAction:@selector(showEditableView:)];

      // We need to subtract the width of the bezel from the frame rect, so that
      // the textfield can take the exact same space as the button.
      frameRect.size.height -= 2 * kBezelThickness;
      frameRect.origin = NSMakePoint(0, kBezelThickness);
      profileNameTextField_.reset(
          [[NSTextField alloc] initWithFrame:frameRect]);
      [profileNameTextField_ setStringValue:profileName];
      [profileNameTextField_ setFont:[NSFont labelFontOfSize:kTitleFontSize]];
      [profileNameTextField_ setEditable:YES];
      [profileNameTextField_ setDrawsBackground:YES];
      [profileNameTextField_ setBezeled:YES];
      [profileNameTextField_ setAlignment:NSCenterTextAlignment];
      [[profileNameTextField_ cell] setWraps:NO];
      [[profileNameTextField_ cell] setLineBreakMode:
          NSLineBreakByTruncatingTail];
      [self addSubview:profileNameTextField_];
      [profileNameTextField_ setTarget:self];
      [profileNameTextField_ setAction:@selector(saveProfileName:)];

      // Hide the textfield until the user clicks on the button.
      [profileNameTextField_ setHidden:YES];
    }

    [self setBordered:NO];
    [self setFont:[NSFont labelFontOfSize:kTitleFontSize]];
    [self setAlignment:NSCenterTextAlignment];
    [[self cell] setLineBreakMode:NSLineBreakByTruncatingTail];
    [self setTitle:profileName];
  }
  return self;
}

- (void)saveProfileName:(id)sender {
  NSString* text = [profileNameTextField_ stringValue];
  // Empty profile names are not allowed, and are treated as a cancel.
  if ([text length] > 0) {
    profiles::UpdateProfileName(profile_, base::SysNSStringToUTF16(text));
    [controller_
        postActionPerformed:ProfileMetrics::PROFILE_DESKTOP_MENU_EDIT_NAME];
    [self setTitle:text];
  }
  [profileNameTextField_ setHidden:YES];
}

- (void)showEditableView:(id)sender {
  [profileNameTextField_ setHidden:NO];
  [[self window] makeFirstResponder:profileNameTextField_];
}

@end

// A custom button that allows for setting a background color when hovered over.
@interface BackgroundColorHoverButton : HoverImageButton {
 @private
  base::scoped_nsobject<NSColor> backgroundColor_;
  base::scoped_nsobject<NSColor> hoverColor_;
}
@end

@implementation BackgroundColorHoverButton

- (id)initWithFrame:(NSRect)frameRect
  imageTitleSpacing:(int)imageTitleSpacing
    backgroundColor:(NSColor*)backgroundColor {
  if ((self = [super initWithFrame:frameRect])) {
    backgroundColor_.reset([backgroundColor retain]);
    hoverColor_.reset([gfx::SkColorToCalibratedNSColor(
        ui::NativeTheme::instance()->GetSystemColor(
            ui::NativeTheme::kColorId_ButtonHoverBackgroundColor)) retain]);

    [self setBordered:NO];
    [self setFont:[NSFont labelFontOfSize:kTextFontSize]];
    [self setButtonType:NSMomentaryChangeButton];

    base::scoped_nsobject<CustomPaddingImageButtonCell> cell(
        [[CustomPaddingImageButtonCell alloc]
            initWithLeftMarginSpacing:kHorizontalSpacing
                    imageTitleSpacing:imageTitleSpacing]);
    [cell setLineBreakMode:NSLineBreakByTruncatingTail];
    [self setCell:cell.get()];
  }
  return self;
}

- (void)setHoverState:(HoverState)state {
  [super setHoverState:state];
  bool isHighlighted = ([self hoverState] != kHoverStateNone);

  NSColor* backgroundColor = isHighlighted ? hoverColor_ : backgroundColor_;
  [[self cell] setBackgroundColor:backgroundColor];
}

@end

// A custom view with the given background color.
@interface BackgroundColorView : NSView {
 @private
  base::scoped_nsobject<NSColor> backgroundColor_;
}
@end

@implementation BackgroundColorView
- (id)initWithFrame:(NSRect)frameRect
          withColor:(NSColor*)color {
  if ((self = [super initWithFrame:frameRect]))
    backgroundColor_.reset([color retain]);
  return self;
}

- (void)drawRect:(NSRect)dirtyRect {
  [backgroundColor_ setFill];
  NSRectFill(dirtyRect);
  [super drawRect:dirtyRect];
}
@end

@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:(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
// enabled if needed.
- (NSView*)buildPreviewTutorialIfNeeded:(const AvatarMenu::Item&)item;

// Creates the main profile card for the profile |item| at the top of
// the bubble.
- (NSView*)createCurrentProfileView:(const AvatarMenu::Item&)item;

// Creates the possible links for the main profile card with profile |item|.
- (NSView*)createCurrentProfileLinksForItem:(const AvatarMenu::Item&)item
                                       rect:(NSRect)rect;

// Creates the disclaimer text for supervised users, telling them that the
// manager can view their history etc.
- (NSView*)createSupervisedUserDisclaimerView;

// Creates a main profile card for the guest user.
- (NSView*)createGuestProfileView;

// Creates an item for the profile |itemIndex| that is used in the fast profile
// switcher in the middle of the bubble.
- (NSButton*)createOtherProfileView:(int)itemIndex;

// Creates the "Not you" and Lock option buttons.
- (NSView*)createOptionsViewWithRect:(NSRect)rect
                          enableLock:(BOOL)enableLock;

// Creates the account management view for the active profile.
- (NSView*)createCurrentProfileAccountsView:(NSRect)rect;

// Creates the list of accounts for the active profile.
- (NSView*)createAccountsListWithRect:(NSRect)rect;

// Creates the Gaia sign-in/add account view.
- (NSView*)buildGaiaEmbeddedView;

// Creates the account removal view.
- (NSView*)buildAccountRemovalView;

// Creates the end-preview view.
- (NSView*)buildEndPreviewView;

// Creates a button with |text|, an icon given by |imageResourceId| and with
// |action|. The icon |alternateImageResourceId| is displayed in the button's
// hovered and pressed states.
- (NSButton*)hoverButtonWithRect:(NSRect)rect
                            text:(NSString*)text
                 imageResourceId:(int)imageResourceId
        alternateImageResourceId:(int)alternateImageResourceId
                          action:(SEL)action;

// Creates a generic link button with |title| and an |action| positioned at
// |frameOrigin|.
- (NSButton*)linkButtonWithTitle:(NSString*)title
                     frameOrigin:(NSPoint)frameOrigin
                          action:(SEL)action;

// Creates an email account button with |title| and a remove icon. If
// |reauthRequired| is true, the button also displays a warning icon. |tag|
// indicates which account the button refers to.
- (NSButton*)accountButtonWithRect:(NSRect)rect
                             title:(const std::string&)title
                               tag:(int)tag
                    reauthRequired:(BOOL)reauthRequired;
@end

@implementation ProfileChooserController
- (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:profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT];
}

- (IBAction)hideAccountManagement:(id)sender {
  [self initMenuContentsWithView:profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER];
}

- (IBAction)lockProfile:(id)sender {
  profiles::LockProfile(browser_->profile());
  [self postActionPerformed:ProfileMetrics::PROFILE_DESKTOP_MENU_LOCK];
}

- (IBAction)showInlineSigninPage:(id)sender {
  [self initMenuContentsWithView:profiles::BUBBLE_VIEW_MODE_GAIA_SIGNIN];
}

- (IBAction)showTabbedSigninPage:(id)sender {
  chrome::ShowBrowserSignin(browser_, signin::SOURCE_MENU);
}

- (IBAction)addAccount:(id)sender {
  [self initMenuContentsWithView:profiles::BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT];
  [self postActionPerformed:ProfileMetrics::PROFILE_DESKTOP_MENU_ADD_ACCT];
}

- (IBAction)navigateBackFromSigninPage:(id)sender {
  std::string primaryAccount = SigninManagerFactory::GetForProfile(
      browser_->profile())->GetAuthenticatedUsername();
  [self initMenuContentsWithView:primaryAccount.empty() ?
      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:profiles::BUBBLE_VIEW_MODE_ACCOUNT_REMOVAL];
}

- (IBAction)showAccountReauthenticationView:(id)sender {
  DCHECK(!isGuestSession_);
  [self initMenuContentsWithView:profiles::BUBBLE_VIEW_MODE_GAIA_REAUTH];
}

- (IBAction)removeAccount:(id)sender {
  DCHECK(!accountIdToRemove_.empty());
  ProfileOAuth2TokenServiceFactory::GetPlatformSpecificForProfile(
      browser_->profile())->RevokeCredentials(accountIdToRemove_);
  [self postActionPerformed:ProfileMetrics::PROFILE_DESKTOP_MENU_REMOVE_ACCT];
  accountIdToRemove_.clear();

  [self initMenuContentsWithView:profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT];
}

- (IBAction)openTutorialLearnMoreURL:(id)sender {
  ProfileMetrics::LogProfileUpgradeEnrollment(
      ProfileMetrics::PROFILE_ENROLLMENT_LAUNCH_LEARN_MORE);
  // 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 {
  ProfileMetrics::LogProfileUpgradeEnrollment(
      ProfileMetrics::PROFILE_ENROLLMENT_ACCEPT_NEW_PROFILE_MGMT);
  profiles::EnableNewProfileManagementPreview(browser_->profile());
}

- (IBAction)dismissTutorial:(id)sender {
  ProfileMetrics::LogProfileUpgradeEnrollment(
      ProfileMetrics::PROFILE_ENROLLMENT_CLOSE_WELCOME_CARD);
  // 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:profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER];
}

- (IBAction)showSendFeedbackTutorial:(id)sender {
  ProfileMetrics::LogProfileUpgradeEnrollment(
      ProfileMetrics::PROFILE_ENROLLMENT_SEND_FEEDBACK);
  tutorialMode_ = profiles::TUTORIAL_MODE_SEND_FEEDBACK;
  [self initMenuContentsWithView:profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER];
}

- (IBAction)showEndPreviewView:(id)sender {
  [self initMenuContentsWithView:profiles::BUBBLE_VIEW_MODE_END_PREVIEW];
}

- (IBAction)sendFeedback:(id)sender {
  chrome::OpenFeedbackDialog(browser_);
}

- (IBAction)endPreviewAndRelaunch:(id)sender {
  profiles::DisableNewProfileManagementPreview(browser_->profile());
}

- (void)cleanUpEmbeddedViewContents {
  webContents_.reset();
}

- (id)initWithBrowser:(Browser*)browser
           anchoredAt:(NSPoint)point
             withMode:(profiles::BubbleViewMode)mode
      withServiceType:(signin::GAIAServiceType)serviceType {
  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_ = profiles::TUTORIAL_MODE_NONE;
    observer_.reset(new ActiveProfileObserverBridge(self, browser_));
    serviceType_ = serviceType;

    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();

    // If view mode is PROFILE_CHOOSER but there is an auth error, force
    // ACCOUNT_MANAGEMENT mode.
    if (viewMode_ == profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER &&
        HasAuthError(browser_->profile())) {
      viewMode_ = profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT;
    }

    [[self bubble] setAlignment:info_bubble::kAlignRightEdgeToAnchorEdge];
    [[self bubble] setArrowLocation:info_bubble::kNoArrow];
    [[self bubble] setBackgroundColor:GetDialogBackgroundColor()];
    [self initMenuContentsWithView:viewMode_];
  }

  return self;
}

- (void)initMenuContentsWithView:(profiles::BubbleViewMode)viewToDisplay {
  if (browser_->profile()->IsSupervised() &&
      (viewToDisplay == profiles::BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT ||
       viewToDisplay == profiles::BUBBLE_VIEW_MODE_ACCOUNT_REMOVAL)) {
    LOG(WARNING) << "Supervised user attempted to add/remove account";
    return;
  }
  viewMode_ = viewToDisplay;
  NSView* contentView = [[self window] contentView];
  [contentView setSubviews:[NSArray array]];
  NSView* subView;

  switch (viewMode_) {
    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 profiles::BUBBLE_VIEW_MODE_ACCOUNT_REMOVAL:
      subView = [self buildAccountRemovalView];
      break;
    case profiles::BUBBLE_VIEW_MODE_END_PREVIEW:
      subView = [self buildEndPreviewView];
      break;
    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;
  // Store the most recently displayed tutorial mode
  profiles::TutorialMode lastTutorialMode = tutorialMode_;

  // 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_ == 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. Add a pixel offset so that the bottom option buttons don't
  // overlap the bubble's rounded corners.
  CGFloat yOffset = 1;

  // 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 horizontalSeparatorWithFrame:rect];
    [container addSubview:separator];
    yOffset = NSMaxY([separator frame]);
  }

  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 horizontalSeparatorWithFrame:NSMakeRect(
          0, yOffset, kFixedMenuWidth, 0)];
      [container addSubview:separator];
      yOffset = NSMaxY([separator frame]);
    }
  }

  // For supervised users, add the disclaimer text.
  if (browser_->profile()->IsSupervised()) {
    yOffset += kSmallVerticalSpacing;
    NSView* disclaimerContainer = [self createSupervisedUserDisclaimerView];
    [disclaimerContainer setFrameOrigin:NSMakePoint(0, yOffset)];
    [container addSubview:disclaimerContainer];
    yOffset = NSMaxY([disclaimerContainer frame]);
    yOffset += kSmallVerticalSpacing;

    NSBox* separator = [self horizontalSeparatorWithFrame:NSMakeRect(
        0, yOffset, kFixedMenuWidth, 0)];
    [container addSubview:separator];
    yOffset = NSMaxY([separator frame]);
  }

  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 horizontalSeparatorWithFrame:
        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]);
    if (!switches::IsNewProfileManagement() &&
        tutorialMode_ != lastTutorialMode) {
      ProfileMetrics::LogProfileUpgradeEnrollment(
          ProfileMetrics::PROFILE_ENROLLMENT_SHOW_PREVIEW_PROMO);
    }
  } else {
    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: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_ == 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_ != profiles::TUTORIAL_MODE_WELCOME) {
    if (showCount == kProfileAvatarTutorialShowMax)
      return nil;
    profile->GetPrefs()->SetInteger(
        prefs::kProfileAvatarTutorialShown, showCount + 1);
  }

  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:(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);
  base::scoped_nsobject<NSView> container([[BackgroundColorView alloc]
      initWithFrame:NSMakeRect(0, 0, kFixedMenuWidth, 0)
          withColor:tutorialBackgroundColor]);
  CGFloat availableWidth = kFixedMenuWidth - 2 * kHorizontalSpacing;
  CGFloat yOffset = kSmallVerticalSpacing;

  // Adds links and buttons at the bottom.
  base::scoped_nsobject<NSButton> tutorialOkButton([[HoverButton alloc]
      initWithFrame:NSZeroRect]);
  [tutorialOkButton setTitle:l10n_util::GetNSString(
      buttonMessageId)];
  [tutorialOkButton setBezelStyle:NSRoundedBezelStyle];
  [tutorialOkButton setTarget:self];
  [tutorialOkButton setAction:buttonAction];
  [tutorialOkButton sizeToFit];
  NSSize buttonSize = [tutorialOkButton frame].size;
  const CGFloat kTopBottomTextPadding = 6;
  const CGFloat kLeftRightTextPadding = 15;
  buttonSize.width += 2 * kLeftRightTextPadding;
  buttonSize.height += 2 * kTopBottomTextPadding;
  [tutorialOkButton setFrameSize:buttonSize];
  [tutorialOkButton setAlignment:NSCenterTextAlignment];
  [tutorialOkButton setFrameOrigin:NSMakePoint(
      kFixedMenuWidth - NSWidth([tutorialOkButton frame]) - kHorizontalSpacing,
      yOffset)];
  [container addSubview:tutorialOkButton];

  NSButton* learnMoreLink =
      [self linkButtonWithTitle:l10n_util::GetNSString(linkMessageId)
                    frameOrigin:NSZeroPoint
                         action:linkAction];
  [[learnMoreLink cell] setTextColor:[NSColor whiteColor]];
  CGFloat linkYOffset = yOffset + (NSHeight([tutorialOkButton frame]) -
                                   NSHeight([learnMoreLink frame])) / 2;
  [learnMoreLink setFrameOrigin:NSMakePoint(kHorizontalSpacing, linkYOffset)];
  [container addSubview:learnMoreLink];

  yOffset = std::max(NSMaxY([learnMoreLink frame]),
                     NSMaxY([tutorialOkButton frame])) + kVerticalSpacing;

  // Adds body content.
  NSTextField* contentLabel = BuildLabel(
      l10n_util::GetNSString(contentMessageId),
      NSMakePoint(kHorizontalSpacing, yOffset),
      tutorialBackgroundColor,
      gfx::SkColorToSRGBNSColor(profiles::kAvatarTutorialContentTextColor));
  [contentLabel setFrameSize:NSMakeSize(availableWidth, 0)];
  [GTMUILocalizerAndLayoutTweaker sizeToFitFixedWidthTextField:contentLabel];
  [container addSubview:contentLabel];
  yOffset = NSMaxY([contentLabel frame]) + kSmallVerticalSpacing;

  // Adds title.
  NSTextField* titleLabel =
      BuildLabel(l10n_util::GetNSString(titleMessageId),
                 NSMakePoint(kHorizontalSpacing, yOffset),
                 tutorialBackgroundColor,
                 [NSColor whiteColor] /* text_color */);
  [titleLabel setFont:[NSFont labelFontOfSize:kTitleFontSize]];
  [titleLabel sizeToFit];
  [titleLabel setFrameSize:
      NSMakeSize(availableWidth, NSHeight([titleLabel frame]))];
  [container addSubview:titleLabel];
  yOffset = NSMaxY([titleLabel frame]) + kVerticalSpacing;

  [container setFrameSize:NSMakeSize(kFixedMenuWidth, yOffset)];

  // Adds caret at the bottom.
  NSImage* caretImage = ui::ResourceBundle::GetSharedInstance().
      GetNativeImageNamed(IDR_ICON_PROFILES_MENU_CARET).AsNSImage();
  base::scoped_nsobject<NSImageView> caretView(
      [[NSImageView alloc] initWithFrame:NSMakeRect(
          kHorizontalSpacing, 0, caretImage.size.width,
          caretImage.size.height)]);
  [caretView setImage:caretImage];

  base::scoped_nsobject<NSView> containerWithCaret([[NSView alloc]
      initWithFrame:NSMakeRect(0, 0, kFixedMenuWidth, 0)]);
  [containerWithCaret addSubview:caretView];

  [container setFrameOrigin:NSMakePoint(0, caretImage.size.height)];
  [containerWithCaret addSubview:container];

  [containerWithCaret setFrameSize:
      NSMakeSize(kFixedMenuWidth, NSMaxY([container frame]))];
  return containerWithCaret.autorelease();
}

- (NSView*)createCurrentProfileView:(const AvatarMenu::Item&)item {
  base::scoped_nsobject<NSView> container([[NSView alloc]
      initWithFrame:NSZeroRect]);

  CGFloat xOffset = kHorizontalSpacing;
  CGFloat yOffset = 0;
  CGFloat availableTextWidth = kFixedMenuWidth - 2 * kHorizontalSpacing;

  // Profile options. This can be a link to the accounts view, the profile's
  // username for signed in users, or a "Sign in" button for local profiles.
  SigninManagerBase* signinManager =
      SigninManagerFactory::GetForProfile(
          browser_->profile()->GetOriginalProfile());
  if (!isGuestSession_ && signinManager->IsSigninAllowed()) {
    NSView* linksContainer =
        [self createCurrentProfileLinksForItem:item
                                          rect:NSMakeRect(xOffset, yOffset,
                                                          availableTextWidth,
                                                          0)];
    [container addSubview:linksContainer];
    yOffset = NSMaxY([linksContainer frame]);
  }

  // Profile name, centered.
  bool editingAllowed = !isGuestSession_ &&
                        !browser_->profile()->IsSupervised();
  base::scoped_nsobject<EditableProfileNameButton> profileName(
      [[EditableProfileNameButton alloc]
          initWithFrame:NSMakeRect(xOffset,
                                   yOffset,
                                   availableTextWidth,
                                   kProfileButtonHeight)
                profile:browser_->profile()
            profileName:base::SysUTF16ToNSString(
                            profiles::GetAvatarNameForProfile(
                                browser_->profile()->GetPath()))
         editingAllowed:editingAllowed
         withController:self]);

  [container addSubview:profileName];
  yOffset = NSMaxY([profileName frame]);

  // Profile icon, centered.
  xOffset = (kFixedMenuWidth - kLargeImageSide) / 2;
  base::scoped_nsobject<EditableProfilePhoto> iconView(
      [[EditableProfilePhoto alloc]
          initWithFrame:NSMakeRect(xOffset, yOffset,
                                   kLargeImageSide, kLargeImageSide)
             avatarMenu:avatarMenu_.get()
            profileIcon:item.icon
         editingAllowed:!isGuestSession_
         withController:self]);

  [container addSubview:iconView];
  yOffset = NSMaxY([iconView frame]);

  if (browser_->profile()->IsSupervised()) {
    base::scoped_nsobject<NSImageView> supervisedIcon(
        [[NSImageView alloc] initWithFrame:NSZeroRect]);
    ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
    [supervisedIcon setImage:rb->GetNativeImageNamed(
        IDR_ICON_PROFILES_MENU_SUPERVISED).ToNSImage()];
    NSSize size = [[supervisedIcon image] size];
    [supervisedIcon setFrameSize:size];
    NSRect parentFrame = [iconView frame];
    [supervisedIcon setFrameOrigin:NSMakePoint(NSMaxX(parentFrame) - size.width,
                                               NSMinY(parentFrame))];
    [container addSubview:supervisedIcon];
  }

  if (switches::IsNewProfileManagementPreviewEnabled()) {
    base::scoped_nsobject<HoverImageButton> questionButton(
        [[HoverImageButton alloc] initWithFrame:NSZeroRect]);
    [questionButton setBordered:NO];
    ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
    [questionButton setDefaultImage:rb->GetNativeImageNamed(
        IDR_ICON_PROFILES_MENU_QUESTION_STABLE).ToNSImage()];
    [questionButton setHoverImage:rb->GetNativeImageNamed(
        IDR_ICON_PROFILES_MENU_QUESTION_HOVER).ToNSImage()];
    [questionButton setPressedImage:rb->GetNativeImageNamed(
        IDR_ICON_PROFILES_MENU_QUESTION_SELECT).ToNSImage()];
    [questionButton setTarget:self];
    [questionButton setAction:@selector(showSendFeedbackTutorial:)];
    [questionButton sizeToFit];
    const CGFloat size = NSHeight([questionButton frame]) + 2;
    [questionButton setFrame:
        NSMakeRect(kHorizontalSpacing, yOffset - size, size, size)];
    [container addSubview:questionButton];
  }

  [container setFrameSize:NSMakeSize(kFixedMenuWidth, yOffset)];
  return container.autorelease();
}

- (NSView*)createCurrentProfileLinksForItem:(const AvatarMenu::Item&)item
                                       rect:(NSRect)rect {
  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_ == profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER ?
              IDS_PROFILES_PROFILE_MANAGE_ACCOUNTS_BUTTON :
              IDS_PROFILES_PROFILE_HIDE_MANAGE_ACCOUNTS_BUTTON);
      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]];
    }
    // -linkButtonWithTitle sizeToFit's the link, so re-stretch it so that it
    // can be centered correctly in the view.
    rect.size.height = NSMaxY([link frame]);
    [link setFrame:rect];
    [link setAlignment:NSCenterTextAlignment];
  } else {
    rect.size.height = kBlueButtonHeight;
    link = [[BlueLabelButton alloc] initWithFrame:rect];

    // Manually elide the button text so that the contents fit inside the bubble
    // This is needed because the BlueLabelButton cell resets the style on
    // every call to -cellSize, which prevents setting a custom lineBreakMode.
    NSString* elidedButtonText = base::SysUTF16ToNSString(gfx::ElideText(
        l10n_util::GetStringFUTF16(
            IDS_SYNC_START_SYNC_BUTTON_LABEL,
            l10n_util::GetStringUTF16(IDS_SHORT_PRODUCT_NAME)),
        gfx::FontList(), rect.size.width, gfx::ELIDE_TAIL));

    [link setTitle:elidedButtonText];
    [link setTarget:self];
    [link setAction:switches::IsNewProfileManagement() ?
        @selector(showInlineSigninPage:) : @selector(showTabbedSigninPage:)];
  }

  [container addSubview:link];
  [container setFrameSize:rect.size];
  return container.autorelease();
}

- (NSView*)createSupervisedUserDisclaimerView {
  base::scoped_nsobject<NSView> container(
      [[NSView alloc] initWithFrame:NSZeroRect]);

  int yOffset = 0;
  int availableTextWidth = kFixedMenuWidth - 2 * kHorizontalSpacing;

  NSTextField* disclaimer = BuildLabel(
      base::SysUTF16ToNSString(avatarMenu_->GetSupervisedUserInformation()),
      NSMakePoint(kHorizontalSpacing, yOffset),
      nil /* background_color */,
      nil /* text_color */);
  [disclaimer setFrameSize:NSMakeSize(availableTextWidth, 0)];
  [GTMUILocalizerAndLayoutTweaker sizeToFitFixedWidthTextField:disclaimer];
  yOffset = NSMaxY([disclaimer frame]);

  [container addSubview:disclaimer];
  [container setFrameSize:NSMakeSize(kFixedMenuWidth, yOffset)];
  return container.autorelease();
}

- (NSView*)createGuestProfileView {
  gfx::Image guestIcon =
      ui::ResourceBundle::GetSharedInstance().GetNativeImageNamed(
          profiles::GetPlaceholderAvatarIconResourceID());
  AvatarMenu::Item guestItem(std::string::npos, /* menu_index, not used */
                             std::string::npos, /* profile_index, not used */
                             guestIcon);
  guestItem.active = true;
  guestItem.name = base::SysNSStringToUTF16(
      l10n_util::GetNSString(IDS_PROFILES_GUEST_PROFILE_NAME));

  return [self createCurrentProfileView:guestItem];
}

- (NSButton*)createOtherProfileView:(int)itemIndex {
  const AvatarMenu::Item& item = avatarMenu_->GetItemAt(itemIndex);

  NSRect rect = NSMakeRect(0, 0, kFixedMenuWidth,
                           kBlueButtonHeight + kSmallVerticalSpacing);
  base::scoped_nsobject<BackgroundColorHoverButton> profileButton(
      [[BackgroundColorHoverButton alloc]
          initWithFrame:rect
      imageTitleSpacing:kImageTitleSpacing
        backgroundColor:GetDialogBackgroundColor()]);
  [profileButton setTitle:base::SysUTF16ToNSString(item.name)];
  [profileButton setDefaultImage:CreateProfileImage(
      item.icon, kSmallImageSide).ToNSImage()];
  [profileButton setImagePosition:NSImageLeft];
  [profileButton setAlignment:NSLeftTextAlignment];
  [profileButton setBordered:NO];
  [profileButton setTag:itemIndex];
  [profileButton setTarget:self];
  [profileButton setAction:@selector(switchToProfile:)];

  return profileButton.autorelease();
}

- (NSView*)createOptionsViewWithRect:(NSRect)rect
                          enableLock:(BOOL)enableLock {
  int widthOfLockButton = enableLock ? 2 * kHorizontalSpacing + 14 : 0;
  NSRect viewRect = NSMakeRect(0, 0,
                               rect.size.width - widthOfLockButton,
                               kBlueButtonHeight + kVerticalSpacing);
  NSString* text = isGuestSession_ ?
      l10n_util::GetNSString(IDS_PROFILES_EXIT_GUEST) :
      l10n_util::GetNSStringF(IDS_PROFILES_NOT_YOU_BUTTON,
          profiles::GetAvatarNameForProfile(
              browser_->profile()->GetPath()));
  NSButton* notYouButton =
      [self hoverButtonWithRect:viewRect
                           text:text
                imageResourceId:IDR_ICON_PROFILES_MENU_AVATAR
       alternateImageResourceId:IDR_ICON_PROFILES_MENU_AVATAR
                         action:isGuestSession_? @selector(exitGuest:) :
                                                 @selector(showUserManager:)];

  rect.size.height = NSMaxY([notYouButton frame]);
  base::scoped_nsobject<NSView> container([[NSView alloc] initWithFrame:rect]);
  [container addSubview:notYouButton];

  if (enableLock) {
    viewRect.origin.x = NSMaxX([notYouButton frame]);
    NSBox* separator = [self verticalSeparatorWithFrame:viewRect];
    [container addSubview:separator];

    viewRect.origin.x = NSMaxX([separator frame]);
    viewRect.size.width = widthOfLockButton;
    NSButton* lockButton =
        [self hoverButtonWithRect:viewRect
                             text:@""
                  imageResourceId:IDR_ICON_PROFILES_MENU_LOCK
         alternateImageResourceId:IDR_ICON_PROFILES_MENU_LOCK
                           action:@selector(lockProfile:)];
    [container addSubview:lockButton];
  }

  return container.autorelease();
}

- (NSView*)createCurrentProfileAccountsView:(NSRect)rect {
  const CGFloat kAccountButtonHeight = 34;

  const AvatarMenu::Item& item =
      avatarMenu_->GetItemAt(avatarMenu_->GetActiveProfileIndex());
  DCHECK(item.signed_in);

  NSColor* backgroundColor = gfx::SkColorToCalibratedNSColor(
      profiles::kAvatarBubbleAccountsBackgroundColor);
  base::scoped_nsobject<NSView> container([[BackgroundColorView alloc]
      initWithFrame:rect
          withColor:backgroundColor]);

  rect.origin.y = 0;
  if (!browser_->profile()->IsSupervised()) {
    // Manually elide the button text so the contents fit inside the bubble.
    // This is needed because the BlueLabelButton cell resets the style on
    // every call to -cellSize, which prevents setting a custom lineBreakMode.
    NSString* elidedButtonText = base::SysUTF16ToNSString(gfx::ElideText(
        l10n_util::GetStringFUTF16(
            IDS_PROFILES_PROFILE_ADD_ACCOUNT_BUTTON, item.name),
        gfx::FontList(), rect.size.width, gfx::ELIDE_TAIL));

    NSButton* addAccountsButton =
        [self linkButtonWithTitle:elidedButtonText
                      frameOrigin:NSMakePoint(
            kHorizontalSpacing, kSmallVerticalSpacing)
                           action:@selector(addAccount:)];
    [container addSubview:addAccountsButton];
    rect.origin.y += kAccountButtonHeight;
  }

  NSView* accountEmails = [self createAccountsListWithRect:NSMakeRect(
      0, rect.origin.y, rect.size.width, kAccountButtonHeight)];
  [container addSubview:accountEmails];

  [container setFrameSize:NSMakeSize(rect.size.width,
                                     NSMaxY([accountEmails frame]))];
  return container.autorelease();
}

- (NSView*)createAccountsListWithRect:(NSRect)rect {
  base::scoped_nsobject<NSView> container([[NSView alloc] initWithFrame:rect]);
  currentProfileAccounts_.clear();

  Profile* profile = browser_->profile();
  std::string primaryAccount =
      SigninManagerFactory::GetForProfile(profile)->GetAuthenticatedUsername();
  DCHECK(!primaryAccount.empty());
  std::vector<std::string>accounts =
      profiles::GetSecondaryAccountsForProfile(profile, primaryAccount);

  // If there is an account with an authentication error, it needs to be
  // badged with a warning icon.
  const SigninErrorController* errorController =
      profiles::GetSigninErrorController(profile);
  std::string errorAccountId =
      errorController ? errorController->error_account_id() : std::string();

  rect.origin.y = 0;
  for (size_t i = 0; i < accounts.size(); ++i) {
    // Save the original email address, as the button text could be elided.
    currentProfileAccounts_[i] = accounts[i];
    NSButton* accountButton =
        [self accountButtonWithRect:rect
                              title:accounts[i]
                                tag:i
                     reauthRequired:errorAccountId == accounts[i]];
    [container addSubview:accountButton];
    rect.origin.y = NSMaxY([accountButton frame]);
  }

  // The primary account should always be listed first.
  NSButton* accountButton =
      [self accountButtonWithRect:rect
                            title:primaryAccount
                              tag:kPrimaryProfileTag
                   reauthRequired:errorAccountId == primaryAccount];
  [container addSubview:accountButton];
  [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;

  GURL url;
  int messageId = -1;
  SigninErrorController* errorController = NULL;
  switch (viewMode_) {
    case profiles::BUBBLE_VIEW_MODE_GAIA_SIGNIN:
      url = signin::GetPromoURL(signin::SOURCE_AVATAR_BUBBLE_SIGN_IN,
                                false /* auto_close */,
                                true /* is_constrained */);
      messageId = IDS_PROFILES_GAIA_SIGNIN_TITLE;
      break;
    case profiles::BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT:
      url = signin::GetPromoURL(signin::SOURCE_AVATAR_BUBBLE_ADD_ACCOUNT,
                                false /* auto_close */,
                                true /* is_constrained */);
      messageId = IDS_PROFILES_GAIA_ADD_ACCOUNT_TITLE;
      break;
    case profiles::BUBBLE_VIEW_MODE_GAIA_REAUTH:
      DCHECK(HasAuthError(browser_->profile()));
      errorController = profiles::GetSigninErrorController(browser_->profile());
      url = signin::GetReauthURL(
          browser_->profile(),
          errorController ? errorController->error_username() : std::string());
      messageId = IDS_PROFILES_GAIA_REAUTH_TITLE;
      break;
    default:
      NOTREACHED() << "Called with invalid mode=" << viewMode_;
      break;
  }

  webContents_.reset(content::WebContents::Create(
      content::WebContents::CreateParams(browser_->profile())));
  webContents_->GetController().LoadURL(url,
                                        content::Referrer(),
                                        content::PAGE_TRANSITION_AUTO_TOPLEVEL,
                                        std::string());
  NSView* webview = webContents_->GetNativeView();
  [webview setFrameSize:NSMakeSize(kFixedGaiaViewWidth, kFixedGaiaViewHeight)];
  [container addSubview:webview];
  yOffset = NSMaxY([webview frame]);

  // Adds the title card.
  NSBox* separator = [self horizontalSeparatorWithFrame:
      NSMakeRect(0, yOffset, kFixedGaiaViewWidth, 0)];
  [container addSubview:separator];
  yOffset = NSMaxY([separator frame]) + kSmallVerticalSpacing;

  NSView* titleView = BuildTitleCard(
      NSMakeRect(0, yOffset, kFixedGaiaViewWidth, 0),
      messageId,
      self /* backButtonTarget*/,
      @selector(navigateBackFromSigninPage:) /* backButtonAction */);
  [container addSubview:titleView];
  yOffset = NSMaxY([titleView frame]);

  [container setFrameSize:NSMakeSize(kFixedGaiaViewWidth, yOffset)];
  return container.autorelease();
}

- (NSView*)buildAccountRemovalView {
  DCHECK(!accountIdToRemove_.empty());

  base::scoped_nsobject<NSView> container(
      [[NSView alloc] initWithFrame:NSZeroRect]);
  CGFloat availableWidth =
      kFixedAccountRemovalViewWidth - 2 * kHorizontalSpacing;
  CGFloat yOffset = kVerticalSpacing;

  const std::string& primaryAccount = SigninManagerFactory::GetForProfile(
      browser_->profile())->GetAuthenticatedUsername();
  bool isPrimaryAccount = primaryAccount == accountIdToRemove_;

  // Adds "remove account" button at the bottom if needed.
  if (!isPrimaryAccount) {
    base::scoped_nsobject<NSButton> removeAccountButton(
        [[BlueLabelButton alloc] initWithFrame:NSZeroRect]);
    [removeAccountButton setTitle:l10n_util::GetNSString(
        IDS_PROFILES_ACCOUNT_REMOVAL_BUTTON)];
    [removeAccountButton setTarget:self];
    [removeAccountButton setAction:@selector(removeAccount:)];
    [removeAccountButton sizeToFit];
    [removeAccountButton setAlignment:NSCenterTextAlignment];
    CGFloat xOffset = (kFixedAccountRemovalViewWidth -
        NSWidth([removeAccountButton frame])) / 2;
    [removeAccountButton setFrameOrigin:NSMakePoint(xOffset, yOffset)];
    [container addSubview:removeAccountButton];

    yOffset = NSMaxY([removeAccountButton frame]) + kVerticalSpacing;
  }

  NSView* contentView;
  NSPoint contentFrameOrigin = NSMakePoint(kHorizontalSpacing, yOffset);
  if (isPrimaryAccount) {
    std::vector<size_t> offsets;
    NSString* contentStr = l10n_util::GetNSStringF(
        IDS_PROFILES_PRIMARY_ACCOUNT_REMOVAL_TEXT,
        base::UTF8ToUTF16(accountIdToRemove_), base::string16(), &offsets);
    NSString* linkStr = l10n_util::GetNSString(IDS_PROFILES_SETTINGS_LINK);
    contentView = BuildFixedWidthTextViewWithLink(self, contentStr, linkStr,
        offsets[1], contentFrameOrigin, availableWidth);
  } else {
    NSString* contentStr =
        l10n_util::GetNSString(IDS_PROFILES_ACCOUNT_REMOVAL_TEXT);
    NSTextField* contentLabel = BuildLabel(contentStr, contentFrameOrigin,
        GetDialogBackgroundColor(), nil /* text_color */);
    [contentLabel setFrameSize:NSMakeSize(availableWidth, 0)];
    [GTMUILocalizerAndLayoutTweaker sizeToFitFixedWidthTextField:contentLabel];
    contentView = contentLabel;
  }
  [container addSubview:contentView];
  yOffset = NSMaxY([contentView frame]) + kVerticalSpacing;

  // Adds the title card.
  NSBox* separator = [self horizontalSeparatorWithFrame:
      NSMakeRect(0, yOffset, kFixedAccountRemovalViewWidth, 0)];
  [container addSubview:separator];
  yOffset = NSMaxY([separator frame]) + kSmallVerticalSpacing;

  NSView* titleView = BuildTitleCard(
      NSMakeRect(0, yOffset, kFixedAccountRemovalViewWidth,0),
      IDS_PROFILES_ACCOUNT_REMOVAL_TITLE,
      self /* backButtonTarget*/,
      @selector(showAccountManagement:) /* backButtonAction */);
  [container addSubview:titleView];
  yOffset = NSMaxY([titleView frame]);

  [container setFrameSize:NSMakeSize(kFixedAccountRemovalViewWidth, yOffset)];
  return container.autorelease();
}

- (NSView*)buildEndPreviewView {
  base::scoped_nsobject<NSView> container(
      [[NSView alloc] initWithFrame:NSZeroRect]);
  CGFloat availableWidth =
      kFixedEndPreviewViewWidth - 2 * kHorizontalSpacing;
  CGFloat yOffset = kVerticalSpacing;

  // Adds the "end preview and relaunch" button at the bottom.
  base::scoped_nsobject<NSButton> endPreviewAndRelaunchButton(
      [[BlueLabelButton alloc] initWithFrame:NSZeroRect]);
  [endPreviewAndRelaunchButton setTitle:l10n_util::GetNSString(
      IDS_PROFILES_END_PREVIEW_AND_RELAUNCH)];
  [endPreviewAndRelaunchButton setTarget:self];
  [endPreviewAndRelaunchButton setAction:@selector(endPreviewAndRelaunch:)];
  [endPreviewAndRelaunchButton sizeToFit];
  [endPreviewAndRelaunchButton setAlignment:NSCenterTextAlignment];
  CGFloat xOffset = (kFixedEndPreviewViewWidth -
      NSWidth([endPreviewAndRelaunchButton frame])) / 2;
  [endPreviewAndRelaunchButton setFrameOrigin:NSMakePoint(xOffset, yOffset)];
  [container addSubview:endPreviewAndRelaunchButton];
  yOffset = NSMaxY([endPreviewAndRelaunchButton frame]) + kVerticalSpacing;

  // Adds the main text label.
  NSPoint contentFrameOrigin = NSMakePoint(kHorizontalSpacing, yOffset);
  NSString* contentStr =
      l10n_util::GetNSString(IDS_PROFILES_END_PREVIEW_TEXT);
  NSTextField* contentLabel = BuildLabel(contentStr, contentFrameOrigin,
      GetDialogBackgroundColor(), nil /* text_color */);
  [contentLabel setFrameSize:NSMakeSize(availableWidth, 0)];
  [GTMUILocalizerAndLayoutTweaker sizeToFitFixedWidthTextField:contentLabel];
  [container addSubview:contentLabel];
  yOffset = NSMaxY([contentLabel frame]) + kVerticalSpacing;

  // Adds the title card.
  NSBox* separator = [self horizontalSeparatorWithFrame:
      NSMakeRect(0, yOffset, kFixedEndPreviewViewWidth, 0)];
  [container addSubview:separator];
  yOffset = NSMaxY([separator frame]) + kSmallVerticalSpacing;

  NSView* titleView = BuildTitleCard(
      NSMakeRect(0, yOffset, kFixedEndPreviewViewWidth, 0),
      IDS_PROFILES_END_PREVIEW,
      self /* backButtonTarget*/,
      @selector(showSendFeedbackTutorial:) /* backButtonAction */);
  [container addSubview:titleView];
  yOffset = NSMaxY([titleView frame]);

  [container setFrameSize:NSMakeSize(kFixedEndPreviewViewWidth, yOffset)];
  return container.autorelease();
}

// Called when clicked on the settings link.
- (BOOL)textView:(NSTextView*)textView
   clickedOnLink:(id)link
         atIndex:(NSUInteger)charIndex {
  chrome::ShowSettings(browser_);
  return YES;
}

- (NSButton*)hoverButtonWithRect:(NSRect)rect
                            text:(NSString*)text
                 imageResourceId:(int)imageResourceId
        alternateImageResourceId:(int)alternateImageResourceId
                          action:(SEL)action {
  base::scoped_nsobject<BackgroundColorHoverButton> button(
      [[BackgroundColorHoverButton alloc]
          initWithFrame:rect
      imageTitleSpacing:kImageTitleSpacing
        backgroundColor:GetDialogBackgroundColor()]);

  [button setTitle:text];
  ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
  NSImage* alternateImage = rb->GetNativeImageNamed(
      alternateImageResourceId).ToNSImage();
  [button setDefaultImage:rb->GetNativeImageNamed(imageResourceId).ToNSImage()];
  [button setHoverImage:alternateImage];
  [button setPressedImage:alternateImage];
  [button setImagePosition:NSImageLeft];
  [button setAlignment:NSLeftTextAlignment];
  [button setBordered:NO];
  [button setTarget:self];
  [button setAction:action];

  return button.autorelease();
}

- (NSButton*)linkButtonWithTitle:(NSString*)title
                     frameOrigin:(NSPoint)frameOrigin
                          action:(SEL)action {
  base::scoped_nsobject<NSButton> link(
      [[HyperlinkButtonCell buttonWithString:title] retain]);

  [[link cell] setShouldUnderline:NO];
  [[link cell] setTextColor:gfx::SkColorToCalibratedNSColor(
      chrome_style::GetLinkColor())];
  [link setTitle:title];
  [link setBordered:NO];
  [link setFont:[NSFont labelFontOfSize:kTextFontSize]];
  [link setTarget:self];
  [link setAction:action];
  [link setFrameOrigin:frameOrigin];
  [link sizeToFit];

  return link.autorelease();
}

- (NSButton*)accountButtonWithRect:(NSRect)rect
                             title:(const std::string&)title
                               tag:(int)tag
                    reauthRequired:(BOOL)reauthRequired {
  ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
  NSImage* deleteImage = rb->GetNativeImageNamed(IDR_CLOSE_1).ToNSImage();
  CGFloat deleteImageWidth = [deleteImage size].width;
  NSImage* warningImage = reauthRequired ? rb->GetNativeImageNamed(
      IDR_ICON_PROFILES_ACCOUNT_BUTTON_ERROR).ToNSImage() : nil;
  CGFloat warningImageWidth = [warningImage size].width;

  CGFloat availableTextWidth = rect.size.width - kHorizontalSpacing -
      warningImageWidth - deleteImageWidth;
  if (warningImage)
    availableTextWidth -= kHorizontalSpacing;

  NSColor* backgroundColor = gfx::SkColorToCalibratedNSColor(
      profiles::kAvatarBubbleAccountsBackgroundColor);
  base::scoped_nsobject<BackgroundColorHoverButton> button(
      [[BackgroundColorHoverButton alloc] initWithFrame:rect
                                      imageTitleSpacing:0
                                        backgroundColor:backgroundColor]);
  [button setTitle:ElideEmail(title, availableTextWidth)];
  [button setAlignment:NSLeftTextAlignment];
  [button setBordered:NO];
  if (reauthRequired) {
    [button setDefaultImage:warningImage];
    [button setImagePosition:NSImageLeft];
    [button setTarget:self];
    [button setAction:@selector(showAccountReauthenticationView:)];
    [button setTag:tag];
  }

  // Delete button.
  if (!browser_->profile()->IsSupervised()) {
    NSRect buttonRect;
    NSDivideRect(rect, &buttonRect, &rect,
        deleteImageWidth + kHorizontalSpacing, NSMaxXEdge);
    buttonRect.origin.y = 0;

    base::scoped_nsobject<HoverImageButton> deleteButton(
        [[HoverImageButton alloc] initWithFrame:buttonRect]);
    [deleteButton setBordered:NO];
    [deleteButton setDefaultImage:deleteImage];
    [deleteButton setHoverImage:rb->GetNativeImageNamed(
        IDR_CLOSE_1_H).ToNSImage()];
    [deleteButton setPressedImage:rb->GetNativeImageNamed(
        IDR_CLOSE_1_P).ToNSImage()];
    [deleteButton setTarget:self];
    [deleteButton setAction:@selector(showAccountRemovalView:)];
    [deleteButton setTag:tag];

    [button addSubview:deleteButton];
  }

  return button.autorelease();
}

- (void)postActionPerformed:(ProfileMetrics::ProfileDesktopMenu)action {
  ProfileMetrics::LogProfileDesktopMenu(action, serviceType_);
  serviceType_ = signin::GAIA_SERVICE_TYPE_NONE;
}

@end