Re-land:

chrome/browser/ui/views/frame/glass_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/glass_browser_frame_view.h"
 
 #include "base/command_line.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/app/chrome_dll_resource.h"
@@ skipping 112 matching lines @@
       std::min(frame_->GetMinimizeButtonOffset(), width());
   int tabstrip_x = browser_view_->ShouldShowOffTheRecordAvatar() ?
       (otr_avatar_bounds_.right() + kOTRSideSpacing) :
       NonClientBorderThickness();
   // In RTL languages, we have moved an avatar icon left by the size of window
   // controls to prevent it from being rendered over them. So, we use its x
   // position to move this tab strip left when maximized. Also, we can render
   // a tab strip until the left end of this window without considering the size
   // of window controls in RTL languages.
   if (base::i18n::IsRTL()) {
-    if (!browser_view_->ShouldShowOffTheRecordAvatar() &&
-        frame_->GetWindow()->IsMaximized())
+    if (!browser_view_->ShouldShowOffTheRecordAvatar() && frame_->IsMaximized())
       tabstrip_x += otr_avatar_bounds_.x();
     minimize_button_offset = width();
   }
   int maximized_spacing =
       kNewTabCaptionMaximizedSpacing +
       (show_profile_button() && profile_button_->IsVisible() ?
           profile_button_->GetPreferredSize().width() +
               ProfileMenuButton::kProfileTagHorizontalSpacing : 0);
   int tabstrip_width = minimize_button_offset - tabstrip_x -
-      (frame_->GetWindow()->IsMaximized() ?
+      (frame_->IsMaximized() ?
           maximized_spacing : kNewTabCaptionRestoredSpacing);
   return gfx::Rect(tabstrip_x, GetHorizontalTabStripVerticalOffset(false),
                    std::max(0, tabstrip_width),
                    tabstrip->GetPreferredSize().height());
 }
 
 int GlassBrowserFrameView::GetHorizontalTabStripVerticalOffset(
     bool restored) const {
   return NonClientTopBorderHeight(restored, true);
 }
@@ skipping 16 matching lines @@
 gfx::Rect GlassBrowserFrameView::GetBoundsForClientView() const {
   return client_view_bounds_;
 }
 
 bool GlassBrowserFrameView::AlwaysUseNativeFrame() const {
   return frame_->AlwaysUseNativeFrame();
 }
 
 gfx::Rect GlassBrowserFrameView::GetWindowBoundsForClientBounds(
     const gfx::Rect& client_bounds) const {
-  HWND hwnd = frame_->GetWindow()->GetNativeWindow();
+  HWND hwnd = frame_->GetNativeWindow();
   if (!browser_view_->IsTabStripVisible() && hwnd) {
     // If we don't have a tabstrip, we're either a popup or an app window, in
     // which case we have a standard size non-client area and can just use
     // AdjustWindowRectEx to obtain it. We check for a non-NULL window handle in
     // case this gets called before the window is actually created.
     RECT rect = client_bounds.ToRECT();
     AdjustWindowRectEx(&rect, GetWindowLong(hwnd, GWL_STYLE), FALSE,
                        GetWindowLong(hwnd, GWL_EXSTYLE));
     return gfx::Rect(rect);
   }
 
   int top_height = NonClientTopBorderHeight(false, false);
   int border_thickness = NonClientBorderThickness();
   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 GlassBrowserFrameView::NonClientHitTest(const gfx::Point& point) {
   // If the browser isn't in normal mode, we haven't customized the frame, so
   // Windows can figure this out.  If the point isn't within our bounds, then
   // it's in the native portion of the frame, so again Windows can figure it
   // out.
   if (!browser_view_->IsBrowserTypeNormal() || !bounds().Contains(point))
     return HTNOWHERE;
 
-  int frame_component =
-      frame_->GetWindow()->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.
   int nonclient_border_thickness = NonClientBorderThickness();
   if (gfx::Rect(nonclient_border_thickness, GetSystemMetrics(SM_CXSIZEFRAME),
                 GetSystemMetrics(SM_CXSMICON),
                 GetSystemMetrics(SM_CYSMICON)).Contains(point))
     return (frame_component == HTCLIENT) ? HTCLIENT : HTSYSMENU;
 
   if (frame_component != HTNOWHERE)
     return frame_component;
 
   // See if the point is within the profile menu button.
   if (show_profile_button() && profile_button_->IsVisible() &&
       profile_button_->GetMirroredBounds().Contains(point))
     return HTCLIENT;
 
   int frame_border_thickness = FrameBorderThickness();
   int window_component = GetHTComponentForFrame(point, frame_border_thickness,
       nonclient_border_thickness, frame_border_thickness,
       kResizeAreaCornerSize - frame_border_thickness,
-      frame_->GetWindow()->window_delegate()->CanResize());
+      frame_->window_delegate()->CanResize());
   // Fall back to the caption if no other component matches.
   return (window_component == HTNOWHERE) ? HTCAPTION : window_component;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // GlassBrowserFrameView, views::ViewMenuDelegate implementation:
 void GlassBrowserFrameView::RunMenu(views::View *source, const gfx::Point &pt) {
   if (profile_menu_model_ == NULL)
     profile_menu_model_.reset(new ProfileMenuModel);
   gfx::Point menu_point(pt.x(),
                         pt.y() + kMenuDisplayOffset);
   profile_menu_model_->RunMenuAt(menu_point);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // GlassBrowserFrameView, views::View overrides:
 
 void GlassBrowserFrameView::OnPaint(gfx::Canvas* canvas) {
   if (!browser_view_->IsTabStripVisible())
     return;  // Nothing is visible, so don't bother to paint.
 
   PaintToolbarBackground(canvas);
   if (browser_view_->ShouldShowOffTheRecordAvatar())
     PaintOTRAvatar(canvas);
-  if (!frame_->GetWindow()->IsMaximized())
+  if (!frame_->IsMaximized())
     PaintRestoredClientEdge(canvas);
 }
 
 void GlassBrowserFrameView::Layout() {
   LayoutOTRAvatar();
   LayoutClientView();
   LayoutProfileTag();
 }
 
 bool GlassBrowserFrameView::HitTest(const gfx::Point& l) const {
   // The ProfileMenuButton intrudes into the client area when the window is
   // maximized.
-  if (frame_->GetWindow()->IsMaximized() && show_profile_button() &&
+  if (frame_->IsMaximized() && show_profile_button() &&
        profile_button_->IsVisible() &&
        profile_button_->GetMirroredBounds().Contains(l)) {
     return true;
   } else {
-    return !GetWindow()->client_view()->bounds().Contains(l);
+    return !frame_->client_view()->bounds().Contains(l);
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // GlassBrowserFrameView, private:
 
 int GlassBrowserFrameView::FrameBorderThickness() const {
-  views::Window* window = frame_->GetWindow();
-  return (window->IsMaximized() || window->IsFullscreen()) ?
+  return (frame_->IsMaximized() || frame_->IsFullscreen()) ?
       0 : GetSystemMetrics(SM_CXSIZEFRAME);
 }
 
 int GlassBrowserFrameView::NonClientBorderThickness() const {
-  views::Window* window = frame_->GetWindow();
-  if (window->IsMaximized() || window->IsFullscreen())
+  if (frame_->IsMaximized() || frame_->IsFullscreen())
     return 0;
 
   return browser_view_->UseVerticalTabs() ?
       kNonClientVerticalTabStripBorderThickness :
       kNonClientBorderThickness;
 }
 
 int GlassBrowserFrameView::NonClientTopBorderHeight(
     bool restored,
     bool ignore_vertical_tabs) const {
-  if (!restored && frame_->GetWindow()->IsFullscreen())
+  if (!restored && frame_->IsFullscreen())
     return 0;
   // We'd like to use FrameBorderThickness() here, but the maximized Aero glass
   // frame has a 0 frame border around most edges and a CYSIZEFRAME-thick border
   // at the top (see AeroGlassFrame::OnGetMinMaxInfo()).
   if (browser_view_->IsTabStripVisible() && !ignore_vertical_tabs &&
       browser_view_->UseVerticalTabs())
     return GetSystemMetrics(SM_CYSIZEFRAME) + GetSystemMetrics(SM_CYCAPTION);
   return GetSystemMetrics(SM_CYSIZEFRAME) +
       ((!restored && browser_view_->IsMaximized()) ?
       -kTabstripTopShadowThickness : kNonClientRestoredExtraThickness);
@@ skipping 117 matching lines @@
 }
 
 void GlassBrowserFrameView::PaintRestoredClientEdge(gfx::Canvas* canvas) {
   ui::ThemeProvider* tp = GetThemeProvider();
   gfx::Rect client_area_bounds = CalculateClientAreaBounds(width(), height());
 
   // The client edges start below the toolbar upper corner images regardless
   // of how tall the toolbar itself is.
   int client_area_top = browser_view_->UseVerticalTabs() ?
       client_area_bounds.y() :
-      (frame_->GetWindow()->client_view()->y() +
+      (frame_->client_view()->y() +
       browser_view_->GetToolbarBounds().y() +
       tp->GetBitmapNamed(IDR_CONTENT_TOP_LEFT_CORNER)->height());
   int client_area_bottom =
       std::max(client_area_top, height() - NonClientBorderThickness());
   int client_area_height = client_area_bottom - client_area_top;
 
   // Draw the client edge images.
   SkBitmap* right = tp->GetBitmapNamed(IDR_CONTENT_RIGHT_SIDE);
   canvas->TileImageInt(*right, client_area_bounds.right(), client_area_top,
                        right->width(), client_area_height);
@@ skipping 40 matching lines @@
   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_->GetWindow()->IsMaximized() ?
+  int otr_y = frame_->IsMaximized() ?
       (NonClientTopBorderHeight(false, true) + kTabstripTopShadowThickness) :
       otr_restored_y;
   otr_avatar_bounds_.SetRect(otr_x, otr_y, otr_avatar_icon.width(),
       browser_view_->ShouldShowOffTheRecordAvatar() ? (otr_bottom - otr_y) : 0);
 }
 
 void GlassBrowserFrameView::LayoutClientView() {
   client_view_bounds_ = CalculateClientAreaBounds(width(), height());
 }
 
@@ skipping 18 matching lines @@
 
   profile_button_->ClearMaxTextSize();
   profile_button_->SetVisible(true);
   int x_tag =
       // The x position of minimize button in the frame
       frame_->GetMinimizeButtonOffset() -
           // - the space between the minimize button and the profile button
           ProfileMenuButton::kProfileTagHorizontalSpacing -
           // - the width of the profile button
           profile_button_->GetPreferredSize().width();
-  int y_maximized_offset = frame_->GetWindow()->IsMaximized() ?
+  int y_maximized_offset = frame_->IsMaximized() ?
       kProfileElementMaximizedYOffset : 0;
   profile_button_->SetBounds(
       x_tag,
       kProfileButtonYPosition + y_maximized_offset,
       profile_button_->GetPreferredSize().width(),
       profile_button_->GetPreferredSize().height());
 
   profile_tag_->SetVisible(true);
   profile_tag_->set_is_signed_in(!profile_name.empty());
   profile_tag_->SetBounds(
@@ skipping 13 matching lines @@
   return gfx::Rect(border_thickness, top_height,
                    std::max(0, width - (2 * border_thickness)),
                    std::max(0, height - top_height - border_thickness));
 }
 
 void GlassBrowserFrameView::StartThrobber() {
   if (!throbber_running_) {
     throbber_running_ = true;
     throbber_frame_ = 0;
     InitThrobberIcons();
-    SendMessage(frame_->GetWindow()->GetNativeWindow(), WM_SETICON,
+    SendMessage(frame_->GetNativeWindow(), WM_SETICON,
                 static_cast<WPARAM>(ICON_SMALL),
                 reinterpret_cast<LPARAM>(throbber_icons_[throbber_frame_]));
   }
 }
 
 void GlassBrowserFrameView::StopThrobber() {
   if (throbber_running_) {
     throbber_running_ = false;
 
     HICON frame_icon = NULL;
 
     // Check if hosted BrowserView has a window icon to use.
     if (browser_view_->ShouldShowWindowIcon()) {
       SkBitmap icon = browser_view_->GetWindowIcon();
       if (!icon.isNull())
         frame_icon = IconUtil::CreateHICONFromSkBitmap(icon);
     }
 
     // Fallback to class icon.
     if (!frame_icon) {
       frame_icon = reinterpret_cast<HICON>(GetClassLongPtr(
-          frame_->GetWindow()->GetNativeWindow(), GCLP_HICONSM));
+          frame_->GetNativeWindow(), GCLP_HICONSM));
     }
 
     // This will reset the small icon which we set in the throbber code.
     // WM_SETICON with NULL icon restores the icon for title bar but not
     // for taskbar. See http://crbug.com/29996
-    SendMessage(frame_->GetWindow()->GetNativeWindow(), WM_SETICON,
+    SendMessage(frame_->GetNativeWindow(), WM_SETICON,
                 static_cast<WPARAM>(ICON_SMALL),
                 reinterpret_cast<LPARAM>(frame_icon));
   }
 }
 
 void GlassBrowserFrameView::DisplayNextThrobberFrame() {
   throbber_frame_ = (throbber_frame_ + 1) % kThrobberIconCount;
-  SendMessage(frame_->GetWindow()->GetNativeWindow(), WM_SETICON,
+  SendMessage(frame_->GetNativeWindow(), WM_SETICON,
               static_cast<WPARAM>(ICON_SMALL),
               reinterpret_cast<LPARAM>(throbber_icons_[throbber_frame_]));
 }
 
 void GlassBrowserFrameView::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)
@@ skipping 11 matching lines @@
   static bool initialized = false;
   if (!initialized) {
     ResourceBundle &rb = ResourceBundle::GetSharedInstance();
     for (int i = 0; i < kThrobberIconCount; ++i) {
       throbber_icons_[i] = rb.LoadThemeIcon(IDI_THROBBER_01 + i);
       DCHECK(throbber_icons_[i]);
     }
     initialized = true;
   }
 }