Revert 88683 - 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 avatar ends 2 px above the bottom of the tabstrip (which, given the
+// The OTR 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 kAvatarBottomSpacing = 2;
-// There are 2 px on each side of the avatar (between the frame border and
+const int kOTRBottomSpacing = 2;
+// There are 2 px on each side of the OTR avatar (between the frame border and
 // it on the left, and between it and the tabstrip on the right).
-const int kAvatarSideSpacing = 2;
+const int kOTRSideSpacing = 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 avatar icon.
+// is no OTR 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 (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.
+  // If multi-profile is enabled set up profile button and login notifications.
   const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
   if (browser_command_line.HasSwitch(switches::kMultiProfiles) &&
-      !browser_view->IsOffTheRecord()) {
+      !browser_view_->ShouldShowOffTheRecordAvatar()) {
     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_->ShouldShowAvatar() ?
-      (avatar_bounds_.right() + kAvatarSideSpacing) :
+  int tabstrip_x = browser_view_->ShouldShowOffTheRecordAvatar() ?
+      (otr_avatar_bounds_.right() + kOTRSideSpacing) :
       NonClientBorderThickness() + kTabStripIndent;
 
-  int maximized_spacing = kNewTabCaptionMaximizedSpacing;
+  int maximized_spacing =
+      kNewTabCaptionMaximizedSpacing +
+      (show_profile_button() && profile_button_->IsVisible() ?
+          profile_button_->GetPreferredSize().width() +
+              ProfileMenuButton::kProfileTagHorizontalSpacing : 0);
   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;
 
-  // 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);
+  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();
-  LayoutAvatar();
+  LayoutOTRAvatar();
+  LayoutProfileTag();
   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)
-    LayoutAvatar();
+    LayoutProfileTag();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // 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::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();
+void OpaqueBrowserFrameView::LayoutOTRAvatar() {
+  SkBitmap otr_avatar_icon = browser_view_->GetOTRAvatarIcon();
+  int otr_bottom, otr_restored_y;
+  if (browser_view_->UseVerticalTabs()) {
+    otr_bottom = NonClientTopBorderHeight(false, false) - kOTRBottomSpacing;
+    otr_restored_y = kFrameShadowThickness;
+  } else {
+    otr_bottom = GetHorizontalTabStripVerticalOffset(false) +
+        browser_view_->GetTabStripHeight() - kOTRBottomSpacing;
+    otr_restored_y = otr_bottom - otr_avatar_icon.height();
+  }
+  int otr_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);
+}
 
-  int avatar_bottom, avatar_restored_y;
-  if (browser_view_->UseVerticalTabs()) {
-    avatar_bottom = NonClientTopBorderHeight(false, false) -
-                    kAvatarBottomSpacing;
-    avatar_restored_y = kFrameShadowThickness;
+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 {
-    avatar_bottom = GetHorizontalTabStripVerticalOffset(false) +
-        browser_view_->GetTabStripHeight() - kAvatarBottomSpacing;
-    avatar_restored_y = avatar_bottom - incognito_icon.height();
+    profile_button_->SetText(UTF16ToWideHack(l10n_util::GetStringUTF16(
+        IDS_PROFILES_NOT_SIGNED_IN_MENU)));
   }
-  int avatar_y = frame_->IsMaximized() ?
-      (NonClientTopBorderHeight(false, true) + kTabstripTopShadowThickness) :
-      avatar_restored_y;
-  avatar_bounds_.SetRect(NonClientBorderThickness() + kAvatarSideSpacing,
-      avatar_y, incognito_icon.width(),
-      browser_view_->ShouldShowAvatar() ? (avatar_bottom - avatar_y) : 0);
+  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 (avatar_button_.get())
-    avatar_button_->SetBoundsRect(avatar_bounds_);
+  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);
+  }
 }
 
 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);
 }