Home | History | Annotate | Download | only in frame 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/ui/views/frame/glass_browser_frame_view.h"
      6 
      7 #include "base/prefs/pref_service.h"
      8 #include "base/strings/utf_string_conversions.h"
      9 #include "chrome/app/chrome_command_ids.h"
     10 #include "chrome/app/chrome_dll_resource.h"
     11 #include "chrome/browser/chrome_notification_types.h"
     12 #include "chrome/browser/profiles/profile.h"
     13 #include "chrome/browser/signin/signin_header_helper.h"
     14 #include "chrome/browser/themes/theme_properties.h"
     15 #include "chrome/browser/ui/views/frame/browser_view.h"
     16 #include "chrome/browser/ui/views/profiles/avatar_menu_button.h"
     17 #include "chrome/browser/ui/views/profiles/new_avatar_button.h"
     18 #include "chrome/browser/ui/views/tabs/tab.h"
     19 #include "chrome/browser/ui/views/tabs/tab_strip.h"
     20 #include "chrome/browser/ui/views/toolbar/toolbar_view.h"
     21 #include "chrome/common/pref_names.h"
     22 #include "components/signin/core/common/profile_management_switches.h"
     23 #include "content/public/browser/notification_service.h"
     24 #include "grit/generated_resources.h"
     25 #include "grit/theme_resources.h"
     26 #include "grit/ui_resources.h"
     27 #include "ui/base/l10n/l10n_util.h"
     28 #include "ui/base/resource/resource_bundle_win.h"
     29 #include "ui/base/theme_provider.h"
     30 #include "ui/gfx/canvas.h"
     31 #include "ui/gfx/icon_util.h"
     32 #include "ui/gfx/image/image.h"
     33 #include "ui/gfx/win/dpi.h"
     34 #include "ui/views/controls/label.h"
     35 #include "ui/views/layout/layout_constants.h"
     36 #include "ui/views/win/hwnd_util.h"
     37 #include "ui/views/window/client_view.h"
     38 
     39 HICON GlassBrowserFrameView::throbber_icons_[
     40     GlassBrowserFrameView::kThrobberIconCount];
     41 
     42 namespace {
     43 // There are 3 px of client edge drawn inside the outer frame borders.
     44 const int kNonClientBorderThickness = 3;
     45 // Besides the frame border, there's another 9 px of empty space atop the
     46 // window in restored mode, to use to drag the window around.
     47 const int kNonClientRestoredExtraThickness = 9;
     48 // In the window corners, the resize areas don't actually expand bigger, but the
     49 // 16 px at the end of the top and bottom edges triggers diagonal resizing.
     50 const int kResizeAreaCornerSize = 16;
     51 // The avatar ends 2 px above the bottom of the tabstrip (which, given the
     52 // way the tabstrip draws its bottom edge, will appear like a 1 px gap to the
     53 // user).
     54 const int kAvatarBottomSpacing = 2;
     55 // Space between the frame border and the left edge of the avatar.
     56 const int kAvatarLeftSpacing = 2;
     57 // Space between the right edge of the avatar and the tabstrip.
     58 const int kAvatarRightSpacing = -2;
     59 // How far the new avatar button is from the left of the minimize button.
     60 const int kNewAvatarButtonOffset = 5;
     61 // The content left/right images have a shadow built into them.
     62 const int kContentEdgeShadowThickness = 2;
     63 // The top 3 px of the tabstrip is shadow; in maximized mode we push this off
     64 // the top of the screen so the tabs appear flush against the screen edge.
     65 const int kTabstripTopShadowThickness = 3;
     66 // In restored mode, the New Tab button isn't at the same height as the caption
     67 // buttons, but the space will look cluttered if it actually slides under them,
     68 // so we stop it when the gap between the two is down to 5 px.
     69 const int kNewTabCaptionRestoredSpacing = 5;
     70 // In maximized mode, where the New Tab button and the caption buttons are at
     71 // similar vertical coordinates, we need to reserve a larger, 16 px gap to avoid
     72 // looking too cluttered.
     73 const int kNewTabCaptionMaximizedSpacing = 16;
     74 // How far to indent the tabstrip from the left side of the screen when there
     75 // is no avatar icon.
     76 const int kTabStripIndent = -6;
     77 
     78 }  // namespace
     79 
     80 ///////////////////////////////////////////////////////////////////////////////
     81 // GlassBrowserFrameView, public:
     82 
     83 GlassBrowserFrameView::GlassBrowserFrameView(BrowserFrame* frame,
     84                                              BrowserView* browser_view)
     85     : BrowserNonClientFrameView(frame, browser_view),
     86       throbber_running_(false),
     87       throbber_frame_(0) {
     88   if (browser_view->ShouldShowWindowIcon())
     89     InitThrobberIcons();
     90 
     91   if (browser_view->IsRegularOrGuestSession() && switches::IsNewAvatarMenu())
     92     UpdateNewStyleAvatarInfo(this, NewAvatarButton::NATIVE_BUTTON);
     93   else
     94     UpdateAvatarInfo();
     95 
     96   if (!browser_view->IsOffTheRecord()) {
     97     registrar_.Add(this, chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED,
     98                    content::NotificationService::AllSources());
     99   }
    100 }
    101 
    102 GlassBrowserFrameView::~GlassBrowserFrameView() {
    103 }
    104 
    105 ///////////////////////////////////////////////////////////////////////////////
    106 // GlassBrowserFrameView, BrowserNonClientFrameView implementation:
    107 
    108 gfx::Rect GlassBrowserFrameView::GetBoundsForTabStrip(
    109     views::View* tabstrip) const {
    110   int minimize_button_offset =
    111       std::min(frame()->GetMinimizeButtonOffset(), width());
    112 
    113   // The new avatar button is optionally displayed to the left of the
    114   // minimize button.
    115   if (new_avatar_button()) {
    116     DCHECK(switches::IsNewAvatarMenu());
    117     minimize_button_offset -= new_avatar_button()->width();
    118   }
    119 
    120   int tabstrip_x = browser_view()->ShouldShowAvatar() ?
    121       (avatar_bounds_.right() + kAvatarRightSpacing) :
    122       NonClientBorderThickness() + kTabStripIndent;
    123   // In RTL languages, we have moved an avatar icon left by the size of window
    124   // controls to prevent it from being rendered over them. So, we use its x
    125   // position to move this tab strip left when maximized. Also, we can render
    126   // a tab strip until the left end of this window without considering the size
    127   // of window controls in RTL languages.
    128   if (base::i18n::IsRTL()) {
    129     if (!browser_view()->ShouldShowAvatar() && frame()->IsMaximized()) {
    130       tabstrip_x += avatar_bounds_.x();
    131     } else if (browser_view()->IsRegularOrGuestSession() &&
    132                switches::IsNewAvatarMenu()) {
    133       tabstrip_x = width() - minimize_button_offset;
    134     }
    135 
    136     minimize_button_offset = width();
    137   }
    138   int tabstrip_width = minimize_button_offset - tabstrip_x -
    139       (frame()->IsMaximized() ?
    140           kNewTabCaptionMaximizedSpacing : kNewTabCaptionRestoredSpacing);
    141   return gfx::Rect(tabstrip_x, NonClientTopBorderHeight(),
    142                    std::max(0, tabstrip_width),
    143                    tabstrip->GetPreferredSize().height());
    144 }
    145 
    146 int GlassBrowserFrameView::GetTopInset() const {
    147   return GetClientAreaInsets().top();
    148 }
    149 
    150 int GlassBrowserFrameView::GetThemeBackgroundXInset() const {
    151   return 0;
    152 }
    153 
    154 void GlassBrowserFrameView::UpdateThrobber(bool running) {
    155   if (throbber_running_) {
    156     if (running) {
    157       DisplayNextThrobberFrame();
    158     } else {
    159       StopThrobber();
    160     }
    161   } else if (running) {
    162     StartThrobber();
    163   }
    164 }
    165 
    166 gfx::Size GlassBrowserFrameView::GetMinimumSize() const {
    167   gfx::Size min_size(browser_view()->GetMinimumSize());
    168 
    169   // Account for the client area insets.
    170   gfx::Insets insets = GetClientAreaInsets();
    171   min_size.Enlarge(insets.width(), insets.height());
    172   // Client area insets do not include the shadow thickness.
    173   min_size.Enlarge(2 * kContentEdgeShadowThickness, 0);
    174 
    175   // Ensure that the minimum width is enough to hold a tab strip with minimum
    176   // width at its usual insets.
    177   if (browser_view()->IsTabStripVisible()) {
    178     TabStrip* tabstrip = browser_view()->tabstrip();
    179     int min_tabstrip_width = tabstrip->GetMinimumSize().width();
    180     int min_tabstrip_area_width =
    181         width() - GetBoundsForTabStrip(tabstrip).width() + min_tabstrip_width;
    182     min_size.set_width(std::max(min_tabstrip_area_width, min_size.width()));
    183   }
    184 
    185   return min_size;
    186 }
    187 
    188 ///////////////////////////////////////////////////////////////////////////////
    189 // GlassBrowserFrameView, views::NonClientFrameView implementation:
    190 
    191 gfx::Rect GlassBrowserFrameView::GetBoundsForClientView() const {
    192   return client_view_bounds_;
    193 }
    194 
    195 gfx::Rect GlassBrowserFrameView::GetWindowBoundsForClientBounds(
    196     const gfx::Rect& client_bounds) const {
    197   HWND hwnd = views::HWNDForWidget(frame());
    198   if (!browser_view()->IsTabStripVisible() && hwnd) {
    199     // If we don't have a tabstrip, we're either a popup or an app window, in
    200     // which case we have a standard size non-client area and can just use
    201     // AdjustWindowRectEx to obtain it. We check for a non-NULL window handle in
    202     // case this gets called before the window is actually created.
    203     RECT rect = client_bounds.ToRECT();
    204     AdjustWindowRectEx(&rect, GetWindowLong(hwnd, GWL_STYLE), FALSE,
    205                        GetWindowLong(hwnd, GWL_EXSTYLE));
    206     return gfx::Rect(rect);
    207   }
    208 
    209   gfx::Insets insets = GetClientAreaInsets();
    210   return gfx::Rect(std::max(0, client_bounds.x() - insets.left()),
    211                    std::max(0, client_bounds.y() - insets.top()),
    212                    client_bounds.width() + insets.width(),
    213                    client_bounds.height() + insets.height());
    214 }
    215 
    216 int GlassBrowserFrameView::NonClientHitTest(const gfx::Point& point) {
    217   // If the browser isn't in normal mode, we haven't customized the frame, so
    218   // Windows can figure this out.  If the point isn't within our bounds, then
    219   // it's in the native portion of the frame, so again Windows can figure it
    220   // out.
    221   if (!browser_view()->IsBrowserTypeNormal() || !bounds().Contains(point))
    222     return HTNOWHERE;
    223 
    224   // See if the point is within the avatar menu button or within the avatar
    225   // label.
    226   if (avatar_button() && avatar_button()->GetMirroredBounds().Contains(point))
    227     return HTCLIENT;
    228 
    229   if (new_avatar_button() &&
    230      new_avatar_button()->GetMirroredBounds().Contains(point))
    231    return HTCLIENT;
    232 
    233   int frame_component = frame()->client_view()->NonClientHitTest(point);
    234 
    235   // See if we're in the sysmenu region.  We still have to check the tabstrip
    236   // first so that clicks in a tab don't get treated as sysmenu clicks.
    237   int nonclient_border_thickness = NonClientBorderThickness();
    238   if (gfx::Rect(nonclient_border_thickness,
    239                 gfx::win::GetSystemMetricsInDIP(SM_CXSIZEFRAME),
    240                 gfx::win::GetSystemMetricsInDIP(SM_CXSMICON),
    241                 gfx::win::GetSystemMetricsInDIP(SM_CYSMICON)).Contains(point))
    242     return (frame_component == HTCLIENT) ? HTCLIENT : HTSYSMENU;
    243 
    244   if (frame_component != HTNOWHERE)
    245     return frame_component;
    246 
    247   int frame_border_thickness = FrameBorderThickness();
    248   int window_component = GetHTComponentForFrame(point, frame_border_thickness,
    249       nonclient_border_thickness, frame_border_thickness,
    250       kResizeAreaCornerSize - frame_border_thickness,
    251       frame()->widget_delegate()->CanResize());
    252   // Fall back to the caption if no other component matches.
    253   return (window_component == HTNOWHERE) ? HTCAPTION : window_component;
    254 }
    255 
    256 ///////////////////////////////////////////////////////////////////////////////
    257 // GlassBrowserFrameView, views::View overrides:
    258 
    259 void GlassBrowserFrameView::OnPaint(gfx::Canvas* canvas) {
    260   if (browser_view()->IsToolbarVisible() &&
    261       browser_view()->toolbar()->ShouldPaintBackground())
    262     PaintToolbarBackground(canvas);
    263   if (!frame()->IsMaximized())
    264     PaintRestoredClientEdge(canvas);
    265 }
    266 
    267 void GlassBrowserFrameView::Layout() {
    268   if (browser_view()->IsRegularOrGuestSession() && switches::IsNewAvatarMenu())
    269     LayoutNewStyleAvatar();
    270   else
    271     LayoutAvatar();
    272 
    273   LayoutClientView();
    274 }
    275 
    276 bool GlassBrowserFrameView::HitTestRect(const gfx::Rect& rect) const {
    277   bool hit_avatar_button = avatar_button() &&
    278       avatar_button()->GetMirroredBounds().Intersects(rect);
    279   bool hit_new_avatar_button = new_avatar_button() &&
    280       new_avatar_button()->GetMirroredBounds().Intersects(rect);
    281   return hit_avatar_button || hit_new_avatar_button ||
    282          !frame()->client_view()->bounds().Intersects(rect);
    283 }
    284 
    285 ///////////////////////////////////////////////////////////////////////////////
    286 // GlassBrowserFrameView, views::ButtonListener overrides:
    287 void GlassBrowserFrameView::ButtonPressed(views::Button* sender,
    288                                           const ui::Event& event) {
    289   if (sender == new_avatar_button()) {
    290     browser_view()->ShowAvatarBubbleFromAvatarButton(
    291         BrowserWindow::AVATAR_BUBBLE_MODE_DEFAULT,
    292         signin::ManageAccountsParams());
    293   }
    294 }
    295 
    296 ///////////////////////////////////////////////////////////////////////////////
    297 // GlassBrowserFrameView, private:
    298 
    299 int GlassBrowserFrameView::FrameBorderThickness() const {
    300   return (frame()->IsMaximized() || frame()->IsFullscreen()) ?
    301       0 : gfx::win::GetSystemMetricsInDIP(SM_CXSIZEFRAME);
    302 }
    303 
    304 int GlassBrowserFrameView::NonClientBorderThickness() const {
    305   if (frame()->IsMaximized() || frame()->IsFullscreen())
    306     return 0;
    307 
    308   return kNonClientBorderThickness;
    309 }
    310 
    311 int GlassBrowserFrameView::NonClientTopBorderHeight() const {
    312   if (frame()->IsFullscreen())
    313     return 0;
    314 
    315   // We'd like to use FrameBorderThickness() here, but the maximized Aero glass
    316   // frame has a 0 frame border around most edges and a CYSIZEFRAME-thick border
    317   // at the top (see AeroGlassFrame::OnGetMinMaxInfo()).
    318   return gfx::win::GetSystemMetricsInDIP(SM_CYSIZEFRAME) +
    319       (!frame()->ShouldLeaveOffsetNearTopBorder() ?
    320       -kTabstripTopShadowThickness : kNonClientRestoredExtraThickness);
    321 }
    322 
    323 void GlassBrowserFrameView::PaintToolbarBackground(gfx::Canvas* canvas) {
    324   ui::ThemeProvider* tp = GetThemeProvider();
    325 
    326   gfx::Rect toolbar_bounds(browser_view()->GetToolbarBounds());
    327   gfx::Point toolbar_origin(toolbar_bounds.origin());
    328   View::ConvertPointToTarget(browser_view(), this, &toolbar_origin);
    329   toolbar_bounds.set_origin(toolbar_origin);
    330   int x = toolbar_bounds.x();
    331   int w = toolbar_bounds.width();
    332   int left_x = x - kContentEdgeShadowThickness;
    333 
    334   gfx::ImageSkia* theme_toolbar = tp->GetImageSkiaNamed(IDR_THEME_TOOLBAR);
    335   gfx::ImageSkia* toolbar_left = tp->GetImageSkiaNamed(
    336       IDR_CONTENT_TOP_LEFT_CORNER);
    337   gfx::ImageSkia* toolbar_center = tp->GetImageSkiaNamed(
    338       IDR_CONTENT_TOP_CENTER);
    339 
    340   // Tile the toolbar image starting at the frame edge on the left and where
    341   // the tabstrip is on the top.
    342   int y = toolbar_bounds.y();
    343   int dest_y = browser_view()->IsTabStripVisible()
    344                    ? y + (kFrameShadowThickness * 2)
    345                    : y;
    346   canvas->TileImageInt(*theme_toolbar,
    347                        x + GetThemeBackgroundXInset(),
    348                        dest_y - GetTopInset(), x,
    349                        dest_y, w, theme_toolbar->height());
    350 
    351   if (browser_view()->IsTabStripVisible()) {
    352     // Draw rounded corners for the tab.
    353     gfx::ImageSkia* toolbar_left_mask =
    354         tp->GetImageSkiaNamed(IDR_CONTENT_TOP_LEFT_CORNER_MASK);
    355     gfx::ImageSkia* toolbar_right_mask =
    356         tp->GetImageSkiaNamed(IDR_CONTENT_TOP_RIGHT_CORNER_MASK);
    357 
    358     // We mask out the corners by using the DestinationIn transfer mode,
    359     // which keeps the RGB pixels from the destination and the alpha from
    360     // the source.
    361     SkPaint paint;
    362     paint.setXfermodeMode(SkXfermode::kDstIn_Mode);
    363 
    364     // Mask out the top left corner.
    365     canvas->DrawImageInt(*toolbar_left_mask, left_x, y, paint);
    366 
    367     // Mask out the top right corner.
    368     int right_x =
    369         x + w + kContentEdgeShadowThickness - toolbar_right_mask->width();
    370     canvas->DrawImageInt(*toolbar_right_mask, right_x, y, paint);
    371 
    372     // Draw left edge.
    373     canvas->DrawImageInt(*toolbar_left, left_x, y);
    374 
    375     // Draw center edge.
    376     canvas->TileImageInt(*toolbar_center, left_x + toolbar_left->width(), y,
    377         right_x - (left_x + toolbar_left->width()), toolbar_center->height());
    378 
    379     // Right edge.
    380     canvas->DrawImageInt(*tp->GetImageSkiaNamed(IDR_CONTENT_TOP_RIGHT_CORNER),
    381                          right_x, y);
    382   }
    383 
    384   // Draw the content/toolbar separator.
    385   canvas->FillRect(
    386       gfx::Rect(x + kClientEdgeThickness,
    387                 toolbar_bounds.bottom() - kClientEdgeThickness,
    388                 w - (2 * kClientEdgeThickness),
    389                 kClientEdgeThickness),
    390       ThemeProperties::GetDefaultColor(
    391           ThemeProperties::COLOR_TOOLBAR_SEPARATOR));
    392 }
    393 
    394 void GlassBrowserFrameView::PaintRestoredClientEdge(gfx::Canvas* canvas) {
    395   ui::ThemeProvider* tp = GetThemeProvider();
    396   gfx::Rect client_area_bounds = CalculateClientAreaBounds(width(), height());
    397 
    398   // The client edges start below the toolbar upper corner images regardless
    399   // of how tall the toolbar itself is.
    400   int client_area_top = frame()->client_view()->y() +
    401       browser_view()->GetToolbarBounds().y() +
    402       tp->GetImageSkiaNamed(IDR_CONTENT_TOP_LEFT_CORNER)->height();
    403   int client_area_bottom =
    404       std::max(client_area_top, height() - NonClientBorderThickness());
    405   int client_area_height = client_area_bottom - client_area_top;
    406 
    407   // Draw the client edge images.
    408   gfx::ImageSkia* right = tp->GetImageSkiaNamed(IDR_CONTENT_RIGHT_SIDE);
    409   canvas->TileImageInt(*right, client_area_bounds.right(), client_area_top,
    410                        right->width(), client_area_height);
    411   canvas->DrawImageInt(
    412       *tp->GetImageSkiaNamed(IDR_CONTENT_BOTTOM_RIGHT_CORNER),
    413       client_area_bounds.right(), client_area_bottom);
    414   gfx::ImageSkia* bottom = tp->GetImageSkiaNamed(IDR_CONTENT_BOTTOM_CENTER);
    415   canvas->TileImageInt(*bottom, client_area_bounds.x(),
    416       client_area_bottom, client_area_bounds.width(),
    417       bottom->height());
    418   gfx::ImageSkia* bottom_left =
    419       tp->GetImageSkiaNamed(IDR_CONTENT_BOTTOM_LEFT_CORNER);
    420   canvas->DrawImageInt(*bottom_left,
    421       client_area_bounds.x() - bottom_left->width(), client_area_bottom);
    422   gfx::ImageSkia* left = tp->GetImageSkiaNamed(IDR_CONTENT_LEFT_SIDE);
    423   canvas->TileImageInt(*left, client_area_bounds.x() - left->width(),
    424       client_area_top, left->width(), client_area_height);
    425 
    426   // Draw the toolbar color so that the client edges show the right color even
    427   // where not covered by the toolbar image.  NOTE: We do this after drawing the
    428   // images because the images are meant to alpha-blend atop the frame whereas
    429   // these rects are meant to be fully opaque, without anything overlaid.
    430   SkColor toolbar_color = tp->GetColor(ThemeProperties::COLOR_TOOLBAR);
    431   canvas->FillRect(gfx::Rect(client_area_bounds.x() - kClientEdgeThickness,
    432       client_area_top, kClientEdgeThickness,
    433       client_area_bottom + kClientEdgeThickness - client_area_top),
    434       toolbar_color);
    435   canvas->FillRect(gfx::Rect(client_area_bounds.x(), client_area_bottom,
    436                              client_area_bounds.width(), kClientEdgeThickness),
    437                    toolbar_color);
    438   canvas->FillRect(gfx::Rect(client_area_bounds.right(), client_area_top,
    439        kClientEdgeThickness,
    440        client_area_bottom + kClientEdgeThickness - client_area_top),
    441        toolbar_color);
    442 }
    443 
    444 void GlassBrowserFrameView::LayoutNewStyleAvatar() {
    445   DCHECK(switches::IsNewAvatarMenu());
    446   if (!new_avatar_button())
    447     return;
    448 
    449   gfx::Size label_size = new_avatar_button()->GetPreferredSize();
    450 
    451   int button_x = frame()->GetMinimizeButtonOffset() -
    452       kNewAvatarButtonOffset - label_size.width();
    453   if (base::i18n::IsRTL())
    454     button_x = width() - frame()->GetMinimizeButtonOffset() +
    455         kNewAvatarButtonOffset;
    456 
    457   // We need to offset the button correctly in maximized mode, so that the
    458   // custom glass style aligns with the native control glass style. The
    459   // glass shadow is off by 1px, which was determined by visual inspection.
    460   int button_y = !frame()->IsMaximized() ? 1 :
    461       NonClientTopBorderHeight() + kTabstripTopShadowThickness - 1;
    462 
    463   new_avatar_button()->SetBounds(
    464       button_x,
    465       button_y,
    466       label_size.width(),
    467       gfx::win::GetSystemMetricsInDIP(SM_CYMENUSIZE) + 1);
    468 }
    469 
    470 void GlassBrowserFrameView::LayoutAvatar() {
    471   // Even though the avatar is used for both incognito and profiles we always
    472   // use the incognito icon to layout the avatar button. The profile icon
    473   // can be customized so we can't depend on its size to perform layout.
    474   gfx::ImageSkia incognito_icon = browser_view()->GetOTRAvatarIcon();
    475 
    476   int avatar_x = NonClientBorderThickness() + kAvatarLeftSpacing;
    477   // Move this avatar icon by the size of window controls to prevent it from
    478   // being rendered over them in RTL languages. This code also needs to adjust
    479   // the width of a tab strip to avoid decreasing this size twice. (See the
    480   // comment in GetBoundsForTabStrip().)
    481   if (base::i18n::IsRTL())
    482     avatar_x += width() - frame()->GetMinimizeButtonOffset();
    483 
    484   int avatar_bottom = GetTopInset() +
    485       browser_view()->GetTabStripHeight() - kAvatarBottomSpacing;
    486   int avatar_restored_y = avatar_bottom - incognito_icon.height();
    487   int avatar_y = frame()->IsMaximized() ?
    488       (NonClientTopBorderHeight() + kTabstripTopShadowThickness) :
    489       avatar_restored_y;
    490   avatar_bounds_.SetRect(avatar_x, avatar_y, incognito_icon.width(),
    491       browser_view()->ShouldShowAvatar() ? (avatar_bottom - avatar_y) : 0);
    492   if (avatar_button())
    493     avatar_button()->SetBoundsRect(avatar_bounds_);
    494 }
    495 
    496 void GlassBrowserFrameView::LayoutClientView() {
    497   client_view_bounds_ = CalculateClientAreaBounds(width(), height());
    498 }
    499 
    500 gfx::Insets GlassBrowserFrameView::GetClientAreaInsets() const {
    501   if (!browser_view()->IsTabStripVisible())
    502     return gfx::Insets();
    503 
    504   const int top_height = NonClientTopBorderHeight();
    505   const int border_thickness = NonClientBorderThickness();
    506   return gfx::Insets(top_height,
    507                      border_thickness,
    508                      border_thickness,
    509                      border_thickness);
    510 }
    511 
    512 gfx::Rect GlassBrowserFrameView::CalculateClientAreaBounds(int width,
    513                                                            int height) const {
    514   gfx::Rect bounds(0, 0, width, height);
    515   bounds.Inset(GetClientAreaInsets());
    516   return bounds;
    517 }
    518 
    519 void GlassBrowserFrameView::StartThrobber() {
    520   if (!throbber_running_) {
    521     throbber_running_ = true;
    522     throbber_frame_ = 0;
    523     InitThrobberIcons();
    524     SendMessage(views::HWNDForWidget(frame()), WM_SETICON,
    525                 static_cast<WPARAM>(ICON_SMALL),
    526                 reinterpret_cast<LPARAM>(throbber_icons_[throbber_frame_]));
    527   }
    528 }
    529 
    530 void GlassBrowserFrameView::StopThrobber() {
    531   if (throbber_running_) {
    532     throbber_running_ = false;
    533 
    534     HICON frame_icon = NULL;
    535 
    536     // Check if hosted BrowserView has a window icon to use.
    537     if (browser_view()->ShouldShowWindowIcon()) {
    538       gfx::ImageSkia icon = browser_view()->GetWindowIcon();
    539       if (!icon.isNull())
    540         frame_icon = IconUtil::CreateHICONFromSkBitmap(*icon.bitmap());
    541     }
    542 
    543     // Fallback to class icon.
    544     if (!frame_icon) {
    545       frame_icon = reinterpret_cast<HICON>(GetClassLongPtr(
    546           views::HWNDForWidget(frame()), GCLP_HICONSM));
    547     }
    548 
    549     // This will reset the small icon which we set in the throbber code.
    550     // WM_SETICON with NULL icon restores the icon for title bar but not
    551     // for taskbar. See http://crbug.com/29996
    552     SendMessage(views::HWNDForWidget(frame()), WM_SETICON,
    553                 static_cast<WPARAM>(ICON_SMALL),
    554                 reinterpret_cast<LPARAM>(frame_icon));
    555   }
    556 }
    557 
    558 void GlassBrowserFrameView::DisplayNextThrobberFrame() {
    559   throbber_frame_ = (throbber_frame_ + 1) % kThrobberIconCount;
    560   SendMessage(views::HWNDForWidget(frame()), WM_SETICON,
    561               static_cast<WPARAM>(ICON_SMALL),
    562               reinterpret_cast<LPARAM>(throbber_icons_[throbber_frame_]));
    563 }
    564 
    565 void GlassBrowserFrameView::Observe(
    566     int type,
    567     const content::NotificationSource& source,
    568     const content::NotificationDetails& details) {
    569   switch (type) {
    570     case chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED:
    571       if (browser_view()->IsRegularOrGuestSession() &&
    572           switches::IsNewAvatarMenu()) {
    573         UpdateNewStyleAvatarInfo(this, NewAvatarButton::NATIVE_BUTTON);
    574       } else {
    575         UpdateAvatarInfo();
    576       }
    577       break;
    578     default:
    579       NOTREACHED() << "Got a notification we didn't register for!";
    580       break;
    581   }
    582 }
    583 
    584 // static
    585 void GlassBrowserFrameView::InitThrobberIcons() {
    586   static bool initialized = false;
    587   if (!initialized) {
    588     for (int i = 0; i < kThrobberIconCount; ++i) {
    589       throbber_icons_[i] =
    590           ui::LoadThemeIconFromResourcesDataDLL(IDI_THROBBER_01 + i);
    591       DCHECK(throbber_icons_[i]);
    592     }
    593     initialized = true;
    594   }
    595 }
    596