Change profile menu button to avatar button

chrome/browser/ui/views/frame/opaque_browser_frame_view.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/views/frame/opaque_browser_frame_view.h"
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/themes/theme_service.h"
+#include "chrome/browser/ui/profile_menu_model.h"
+#include "chrome/browser/ui/views/avatar_menu_button.h"
 #include "chrome/browser/ui/views/frame/browser_frame.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
-#include "chrome/browser/ui/views/profile_menu_button.h"
-#include "chrome/browser/ui/views/profile_tag_view.h"
 #include "chrome/browser/ui/views/tabs/tab_strip.h"
 #include "chrome/browser/ui/views/toolbar_view.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/notification_service.h"
 #include "grit/app_resources.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
@@ skipping 40 matching lines @@
 // The titlebar has a 2 px 3D edge along the top and bottom.
 const int kTitlebarTopAndBottomEdgeThickness = 2;
 // The icon is inset 2 px from the left frame border.
 const int kIconLeftSpacing = 2;
 // The icon never shrinks below 16 px on a side.
 const int kIconMinimumSize = 16;
 // There is a 4 px gap between the icon and the title text.
 const int kIconTitleSpacing = 4;
 // There is a 5 px gap between the title text and the caption buttons.
 const int kTitleLogoSpacing = 5;
-// The OTR avatar ends 2 px above the bottom of the tabstrip (which, given the
+// The avatar ends 2 px above the bottom of the tabstrip (which, given the
 // way the tabstrip draws its bottom edge, will appear like a 1 px gap to the
 // user).
-const int kOTRBottomSpacing = 2;
-// There are 2 px on each side of the OTR avatar (between the frame border and
+const int kAvatarBottomSpacing = 2;
+// There are 2 px on each side of the avatar (between the frame border and
 // it on the left, and between it and the tabstrip on the right).
-const int kOTRSideSpacing = 2;
+const int kAvatarSideSpacing = 2;
 // The top 1 px of the tabstrip is shadow; in maximized mode we push this off
 // the top of the screen so the tabs appear flush against the screen edge.
 const int kTabstripTopShadowThickness = 1;
 // In restored mode, the New Tab button isn't at the same height as the caption
 // buttons, but the space will look cluttered if it actually slides under them,
 // so we stop it when the gap between the two is down to 5 px.
 const int kNewTabCaptionRestoredSpacing = 5;
 // In maximized mode, where the New Tab button and the caption buttons are at
 // similar vertical coordinates, we need to reserve a larger, 16 px gap to avoid
 // looking too cluttered.
 const int kNewTabCaptionMaximizedSpacing = 16;
 // How far to indent the tabstrip from the left side of the screen when there
-// is no OTR icon.
+// is no avatar icon.
 const int kTabStripIndent = 1;
 // Inset from the top of the toolbar/tabstrip to the shadow. Used only for
 // vertical tabs.
 const int kVerticalTabBorderInset = 3;
-// Y position for profile tag inside the frame.
-const int kProfileTagYPosition = 1;
 
 // Converts |bounds| from |src|'s coordinate system to |dst|, and checks if
 // |pt| is contained within.
 bool ConvertedContainsCheck(gfx::Rect bounds, const views::View* src,
                             const views::View* dst, const gfx::Point& pt) {
   DCHECK(src);
   DCHECK(dst);
   gfx::Point origin(bounds.origin());
   views::View::ConvertPointToView(src, dst, &origin);
   bounds.set_origin(origin);
@@ skipping 80 matching lines @@
   AddChildView(close_button_);
 
   // Initializing the TabIconView is expensive, so only do it if we need to.
   if (browser_view_->ShouldShowWindowIcon()) {
     window_icon_ = new TabIconView(this);
     window_icon_->set_is_light(true);
     AddChildView(window_icon_);
     window_icon_->Update();
   }
 
-  // If multi-profile is enabled set up profile button and login notifications.
+  if (browser_view_->ShouldShowAvatar()) {
+    ui::MenuModel* menu_model = browser_view_->IsOffTheRecord() ?
+        NULL : new ProfileMenuModel;
+    // AvatarMenuButton takes ownership of |menu_model|.
+    avatar_button_.reset(new AvatarMenuButton(std::wstring(), menu_model));
+    AddChildView(avatar_button_.get());
+
+    if (browser_view_->IsOffTheRecord()) {
+      avatar_button_->SetIcon(browser_view_->GetOTRAvatarIcon());
+    } else {
+      // TODO(sail) Get the avatar icon assigned to this profile.
+      ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+      avatar_button_->SetIcon(*rb.GetBitmapNamed(IDR_PROFILE_AVATAR_1));
+      // TODO(sail) Also need to call SetHoverIcon() and SetPushedIcon().
+    }
+  }
+
+  // If multi-profile is enabled set up login notifications.
   const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
   if (browser_command_line.HasSwitch(switches::kMultiProfiles) &&
-      !browser_view_->ShouldShowOffTheRecordAvatar()) {
+      !browser_view->IsOffTheRecord()) {
     RegisterLoginNotifications();
-    profile_button_.reset(new ProfileMenuButton(std::wstring(),
-        browser_view_->browser()->profile()));
-    profile_button_->SetVisible(false);
-    profile_tag_.reset(new ProfileTagView(frame_, profile_button_.get()));
-    profile_tag_->SetVisible(false);
-    AddChildView(profile_tag_.get());
-    AddChildView(profile_button_.get());
   }
 }
 
 OpaqueBrowserFrameView::~OpaqueBrowserFrameView() {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // OpaqueBrowserFrameView, protected:
 
 int OpaqueBrowserFrameView::GetReservedHeight() const {
@@ skipping 37 matching lines @@
   if (!tabstrip)
     return gfx::Rect();
 
   if (browser_view_->UseVerticalTabs()) {
     gfx::Size ps = tabstrip->GetPreferredSize();
     return gfx::Rect(NonClientBorderThickness(),
         NonClientTopBorderHeight(false, false), ps.width(),
         browser_view_->height());
   }
 
-  int tabstrip_x = browser_view_->ShouldShowOffTheRecordAvatar() ?
-      (otr_avatar_bounds_.right() + kOTRSideSpacing) :
+  int tabstrip_x = browser_view_->ShouldShowAvatar() ?
+      (avatar_bounds_.right() + kAvatarSideSpacing) :
       NonClientBorderThickness() + kTabStripIndent;
 
-  int maximized_spacing =
-      kNewTabCaptionMaximizedSpacing +
-      (show_profile_button() && profile_button_->IsVisible() ?
-          profile_button_->GetPreferredSize().width() +
-              ProfileMenuButton::kProfileTagHorizontalSpacing : 0);
+  int maximized_spacing = kNewTabCaptionMaximizedSpacing;
   int tabstrip_width = minimize_button_->x() - tabstrip_x -
       (frame_->IsMaximized() ?
           maximized_spacing : kNewTabCaptionRestoredSpacing);
   return gfx::Rect(tabstrip_x, GetHorizontalTabStripVerticalOffset(false),
       std::max(0, tabstrip_width), tabstrip->GetPreferredSize().height());
 }
 
 int OpaqueBrowserFrameView::GetHorizontalTabStripVerticalOffset(
     bool restored) const {
   return NonClientTopBorderHeight(restored, true) + ((!restored &&
@@ skipping 42 matching lines @@
   return gfx::Rect(std::max(0, client_bounds.x() - border_thickness),
                    std::max(0, client_bounds.y() - top_height),
                    client_bounds.width() + (2 * border_thickness),
                    client_bounds.height() + top_height + border_thickness);
 }
 
 int OpaqueBrowserFrameView::NonClientHitTest(const gfx::Point& point) {
   if (!bounds().Contains(point))
     return HTNOWHERE;
 
-  int frame_component =
-      frame_->client_view()->NonClientHitTest(point);
+  // See if the point is within the avatar menu button.
+  if (avatar_button_.get() &&
+      avatar_button_->GetMirroredBounds().Contains(point))
+    return HTCLIENT;
+
+  int frame_component = frame_->client_view()->NonClientHitTest(point);
 
   // See if we're in the sysmenu region.  We still have to check the tabstrip
   // first so that clicks in a tab don't get treated as sysmenu clicks.
   gfx::Rect sysmenu_rect(IconBounds());
   // In maximized mode we extend the rect to the screen corner to take advantage
   // of Fitts' Law.
   if (frame_->IsMaximized())
     sysmenu_rect.SetRect(0, 0, sysmenu_rect.right(), sysmenu_rect.bottom());
   sysmenu_rect.set_x(GetMirroredXForRect(sysmenu_rect));
   if (sysmenu_rect.Contains(point))
     return (frame_component == HTCLIENT) ? HTCLIENT : HTSYSMENU;
 
   if (frame_component != HTNOWHERE)
     return frame_component;
 
   // Then see if the point is within any of the window controls.
   if (close_button_->IsVisible() &&
       close_button_->GetMirroredBounds().Contains(point))
     return HTCLOSE;
   if (restore_button_->IsVisible() &&
       restore_button_->GetMirroredBounds().Contains(point))
     return HTMAXBUTTON;
   if (maximize_button_->IsVisible() &&
       maximize_button_->GetMirroredBounds().Contains(point))
     return HTMAXBUTTON;
   if (minimize_button_->IsVisible() &&
       minimize_button_->GetMirroredBounds().Contains(point))
     return HTMINBUTTON;
 
-  // See if the point is within the profile menu button.
-  if (show_profile_button() && profile_button_->IsVisible() &&
-      profile_button_->GetMirroredBounds().Contains(point))
-    return HTCLIENT;
-
   views::WindowDelegate* delegate = frame_->window_delegate();
   if (!delegate) {
     LOG(WARNING) << "delegate is NULL, returning safe default.";
     return HTCAPTION;
   }
   int window_component = GetHTComponentForFrame(point, TopResizeHeight(),
       NonClientBorderThickness(), kResizeAreaCornerSize, kResizeAreaCornerSize,
       delegate->CanResize());
   // Fall back to the caption if no other component matches.
   return (window_component == HTNOWHERE) ? HTCAPTION : window_component;
@@ skipping 32 matching lines @@
     return;  // Nothing is visible, so don't bother to paint.
 
   if (frame_->IsMaximized())
     PaintMaximizedFrameBorder(canvas);
   else
     PaintRestoredFrameBorder(canvas);
   PaintTitleBar(canvas);
   if (browser_view_->IsToolbarVisible() ||
       browser_view_->UseCompactNavigationBar())
     PaintToolbarBackground(canvas);
-  if (browser_view_->ShouldShowOffTheRecordAvatar())
-    PaintOTRAvatar(canvas);
   if (!frame_->IsMaximized())
     PaintRestoredClientEdge(canvas);
 }
 
 void OpaqueBrowserFrameView::Layout() {
   LayoutWindowControls();
   LayoutTitleBar();
-  LayoutOTRAvatar();
-  LayoutProfileTag();
+  LayoutAvatar();
   client_view_bounds_ = CalculateClientAreaBounds(width(), height());
 }
 
 bool OpaqueBrowserFrameView::HitTest(const gfx::Point& l) const {
   // If the point is outside the bounds of the client area, claim it.
   bool in_nonclient = NonClientFrameView::HitTest(l);
   if (in_nonclient)
     return in_nonclient;
 
   // Otherwise claim it only if it's in a non-tab portion of the tabstrip.
@@ skipping 65 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // OpaqueBrowserFrameView, protected:
 
 void OpaqueBrowserFrameView::Observe(NotificationType type,
                                      const NotificationSource& source,
                                      const NotificationDetails& details) {
   DCHECK_EQ(NotificationType::PREF_CHANGED, type.value);
   std::string* name = Details<std::string>(details).ptr();
   if (prefs::kGoogleServicesUsername == *name)
-    LayoutProfileTag();
+    LayoutAvatar();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // OpaqueBrowserFrameView, private:
 
 int OpaqueBrowserFrameView::FrameBorderThickness(bool restored) const {
   return (!restored && (frame_->IsMaximized() || frame_->IsFullscreen())) ?
       0 : kFrameBorderThickness;
 }
 
@@ skipping 380 matching lines @@
       toolbar_right->height() - bottom_edge_height, toolbar_right->width(),
       bottom_edge_height, right_x, bottom_y, toolbar_right->width(),
       bottom_edge_height, false);
 
   // Draw the content/toolbar separator.
   canvas->FillRectInt(ResourceBundle::toolbar_separator_color,
       x + kClientEdgeThickness, toolbar_bounds.bottom() - kClientEdgeThickness,
       w - (2 * kClientEdgeThickness), kClientEdgeThickness);
 }
 
-void OpaqueBrowserFrameView::PaintOTRAvatar(gfx::Canvas* canvas) {
-  // In RTL mode, the avatar icon should be looking the opposite direction.
-  canvas->Save();
-  if (base::i18n::IsRTL()) {
-    canvas->TranslateInt(width(), 0);
-    canvas->ScaleInt(-1, 1);
-  }
-
-  SkBitmap otr_avatar_icon = browser_view_->GetOTRAvatarIcon();
-  int w = otr_avatar_bounds_.width();
-  int h = otr_avatar_bounds_.height();
-  canvas->DrawBitmapInt(otr_avatar_icon, 0,
-      // Bias the rounding to select a region that's lower rather than higher,
-      // as the shadows at the image top mean the apparent center is below the
-      // real center.
-      ((otr_avatar_icon.height() - otr_avatar_bounds_.height()) + 1) / 2, w, h,
-      otr_avatar_bounds_.x(), otr_avatar_bounds_.y(), w, h, false);
-
-  canvas->Restore();
-}
-
 void OpaqueBrowserFrameView::PaintRestoredClientEdge(gfx::Canvas* canvas) {
   ui::ThemeProvider* tp = GetThemeProvider();
   int client_area_top = frame_->client_view()->y();
   int image_top = client_area_top;
 
   gfx::Rect client_area_bounds = CalculateClientAreaBounds(width(), height());
   SkColor toolbar_color = tp->GetColor(ThemeService::COLOR_TOOLBAR);
 
   if (browser_view_->IsToolbarVisible() ||
       browser_view_->UseCompactNavigationBar()) {
@@ skipping 168 matching lines @@
     // vertical midline rather than below.  This compensates for how the icon is
     // already biased downwards (see IconBounds()) and helps prevent descenders
     // on the title from overlapping the 3D edge at the bottom of the titlebar.
     title_bounds_.SetRect(title_x,
         icon_bounds.y() + ((icon_bounds.height() - title_height - 1) / 2),
         std::max(0, minimize_button_->x() - kTitleLogoSpacing - title_x),
         title_height);
   }
 }
 
-void OpaqueBrowserFrameView::LayoutOTRAvatar() {
-  SkBitmap otr_avatar_icon = browser_view_->GetOTRAvatarIcon();
-  int otr_bottom, otr_restored_y;
+void OpaqueBrowserFrameView::LayoutAvatar() {
+  // Even though the avatar is used for both incognito and profiles we always
+  // use the incognito icon to layout the avatar button.
+  SkBitmap incognito_icon = browser_view_->GetOTRAvatarIcon();
+
+  int avatar_bottom, avatar_restored_y;
   if (browser_view_->UseVerticalTabs()) {
-    otr_bottom = NonClientTopBorderHeight(false, false) - kOTRBottomSpacing;
-    otr_restored_y = kFrameShadowThickness;
+    avatar_bottom = NonClientTopBorderHeight(false, false) -
+                    kAvatarBottomSpacing;
+    avatar_restored_y = kFrameShadowThickness;
   } else {
-    otr_bottom = GetHorizontalTabStripVerticalOffset(false) +
-        browser_view_->GetTabStripHeight() - kOTRBottomSpacing;
-    otr_restored_y = otr_bottom - otr_avatar_icon.height();
+    avatar_bottom = GetHorizontalTabStripVerticalOffset(false) +
+        browser_view_->GetTabStripHeight() - kAvatarBottomSpacing;
+    avatar_restored_y = avatar_bottom - incognito_icon.height();
   }
-  int otr_y = frame_->IsMaximized() ?
+  int avatar_y = frame_->IsMaximized() ?
       (NonClientTopBorderHeight(false, true) + kTabstripTopShadowThickness) :
-      otr_restored_y;
-  otr_avatar_bounds_.SetRect(NonClientBorderThickness() + kOTRSideSpacing,
-      otr_y, otr_avatar_icon.width(),
-      browser_view_->ShouldShowOffTheRecordAvatar() ? (otr_bottom - otr_y) : 0);
-}
+      avatar_restored_y;
+  avatar_bounds_.SetRect(NonClientBorderThickness() + kAvatarSideSpacing,
+      avatar_y, incognito_icon.width(),
+      browser_view_->ShouldShowAvatar() ? (avatar_bottom - avatar_y) : 0);
 
-void OpaqueBrowserFrameView::LayoutProfileTag() {
-  if (!show_profile_button())
-    return;
-
-  string16 profile_name = UTF8ToUTF16(browser_view_->browser()->profile()->
-      GetPrefs()->GetString(prefs::kGoogleServicesUsername));
-  if (!profile_name.empty()) {
-    profile_button_->SetText(UTF16ToWideHack(profile_name));
-  } else {
-    profile_button_->SetText(UTF16ToWideHack(l10n_util::GetStringUTF16(
-        IDS_PROFILES_NOT_SIGNED_IN_MENU)));
-  }
-  profile_button_->SetTextShadowColors(ProfileMenuButton::kDarkTextShadow,
-                                       ProfileMenuButton::kDarkTextShadow);
-  profile_button_->ClearMaxTextSize();
-  profile_button_->SetVisible(true);
-  int x_tag =
-      // The x position of minimize button in the frame
-      minimize_button_->x() -
-          // - the space between the minimize button and the profile button
-          ProfileMenuButton::kProfileTagHorizontalSpacing -
-          // - the width of the profile button
-          profile_button_->GetPreferredSize().width();
-  // Adjust for different default font sizes on different Windows platforms.
-  int y_tag = profile_button_->font().GetHeight() < 14 ? 2 : 0;
-  int maximized = frame_->IsMaximized();
-  profile_button_->SetBounds(
-      x_tag,
-      maximized ? 0 : y_tag,
-      profile_button_->GetPreferredSize().width(),
-      profile_button_->GetPreferredSize().height());
-
-  if (!profile_name.empty()) {
-    profile_tag_->SetVisible(true);
-    profile_tag_->SetBounds(
-        x_tag,
-        maximized ? 0 : kProfileTagYPosition,
-        profile_button_->GetPreferredSize().width(),
-        ProfileTagView::kProfileTagHeight);
-  } else {
-    profile_tag_->SetVisible(false);
-  }
+  if (avatar_button_.get())
+    avatar_button_->SetBoundsRect(avatar_bounds_);
 }
 
 gfx::Rect OpaqueBrowserFrameView::CalculateClientAreaBounds(int width,
                                                             int height) const {
   int top_height = NonClientTopBorderHeight(false, false);
   int border_thickness = NonClientBorderThickness();
   return gfx::Rect(border_thickness, top_height,
                    std::max(0, width - (2 * border_thickness)),
                    std::max(0, height - GetReservedHeight() -
                        top_height - border_thickness));
 }
 
 void OpaqueBrowserFrameView::RegisterLoginNotifications() {
   PrefService* pref_service = browser_view_->browser()->profile()->GetPrefs();
   DCHECK(pref_service);
   username_pref_.Init(prefs::kGoogleServicesUsername, pref_service, this);
 }