Re-land:

chrome/browser/ui/views/frame/browser_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/browser_view.h"
 
 #if defined(TOOLKIT_USES_GTK)
 #include <gtk/gtk.h>
 #endif
 
@@ skipping 274 matching lines @@
       SetBounds(parent()->width() - ps.width(),
                 parent()->height() - ps.height(), ps.width(), ps.height());
     }
   }
 
  private:
   // Returns the WindowWin we're displayed in. Returns NULL if we're not
   // currently in a window.
   views::Window* GetWindow() {
     views::Widget* widget = GetWidget();
-    return widget ? widget->GetWindow() : NULL;
+    return widget ? widget->GetContainingWindow() : NULL;
   }
 
   DISALLOW_COPY_AND_ASSIGN(ResizeCorner);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserView, public:
 
 BrowserView::BrowserView(Browser* browser)
     : views::ClientView(NULL, NULL),
@@ skipping 266 matching lines @@
   // The same fix as in BrowserWindowGtk::Show.
   //
   // The Browser must become the active browser when Show() is called.
   // But, on Gtk, the browser won't be shown until we return to the runloop.
   // Therefore we need to set the active window here explicitly. otherwise
   // any calls to BrowserList::GetLastActive() (for example, in bookmark_util),
   // will return the previous browser.
   BrowserList::SetLastActive(browser());
 
   // If the window is already visible, just activate it.
-  if (frame_->GetWindow()->IsVisible()) {
-    frame_->GetWindow()->Activate();
+  if (frame_->IsVisible()) {
+    frame_->Activate();
     return;
   }
 
   // Setting the focus doesn't work when the window is invisible, so any focus
   // initialization that happened before this will be lost.
   //
   // We really "should" restore the focus whenever the window becomes unhidden,
   // but I think initializing is the only time where this can happen where
   // there is some focus change we need to pick up, and this is easier than
   // plumbing through an un-hide message all the way from the frame.
   //
   // If we do find there are cases where we need to restore the focus on show,
   // that should be added and this should be removed.
   RestoreFocus();
 
-  frame_->GetWindow()->Show();
+  frame_->Show();
 }
 
 void BrowserView::ShowInactive() {
-  views::Window* window = frame_->GetWindow();
-  if (!window->IsVisible())
-    window->ShowInactive();
+  if (!frame_->IsVisible())
+    frame_->ShowInactive();
 }
 
 void BrowserView::SetBounds(const gfx::Rect& bounds) {
   SetFullscreen(false);
   GetWidget()->SetBounds(bounds);
 }
 
 void BrowserView::Close() {
   BrowserBubbleHost::Close();
 
-  frame_->GetWindow()->CloseWindow();
+  frame_->Close();
 }
 
 void BrowserView::Activate() {
-  frame_->GetWindow()->Activate();
+  frame_->Activate();
 }
 
 void BrowserView::Deactivate() {
-  frame_->GetWindow()->Deactivate();
+  frame_->Deactivate();
 }
 
 bool BrowserView::IsActive() const {
-  return frame_->GetWindow()->IsActive();
+  return frame_->IsActive();
 }
 
 void BrowserView::FlashFrame() {
 #if defined(OS_WIN)
   FLASHWINFO fwi;
   fwi.cbSize = sizeof(fwi);
-  fwi.hwnd = frame_->GetWindow()->GetNativeWindow();
+  fwi.hwnd = frame_->GetNativeWindow();
   fwi.dwFlags = FLASHW_ALL;
   fwi.uCount = 4;
   fwi.dwTimeout = 0;
   FlashWindowEx(&fwi);
 #else
   // Doesn't matter for chrome os.
 #endif
 }
 
 gfx::NativeWindow BrowserView::GetNativeHandle() {
-  return GetWidget()->GetWindow()->GetNativeWindow();
+  return GetWidget()->GetContainingWindow()->GetNativeWindow();
 }
 
 BrowserWindowTesting* BrowserView::GetBrowserWindowTesting() {
   return this;
 }
 
 StatusBubble* BrowserView::GetStatusBubble() {
   return status_bubble_.get();
 }
 
@@ skipping 44 matching lines @@
   // with a gray rect because the clip wasn't updated.  Note that a reentrant
   // call never needs to do this, because after it returns, the normal call
   // wrapping it will do it.
   if ((call_state == NORMAL) && !is_animating) {
     contents_container_->InvalidateLayout();
     contents_split_->Layout();
   }
 }
 
 void BrowserView::UpdateTitleBar() {
-  frame_->GetWindow()->UpdateWindowTitle();
+  frame_->UpdateWindowTitle();
   if (ShouldShowWindowIcon() && !loading_animation_timer_.IsRunning())
-    frame_->GetWindow()->UpdateWindowIcon();
+    frame_->UpdateWindowIcon();
 }
 
 void BrowserView::ShelfVisibilityChanged() {
   Layout();
 }
 
 void BrowserView::UpdateDevTools() {
   UpdateDevToolsForContents(GetSelectedTabContentsWrapper());
   Layout();
 }
@@ skipping 15 matching lines @@
       LoadingAnimationCallback();
     }
   }
 }
 
 void BrowserView::SetStarredState(bool is_starred) {
   GetLocationBarView()->SetStarToggled(is_starred);
 }
 
 gfx::Rect BrowserView::GetRestoredBounds() const {
-  return frame_->GetWindow()->GetNormalBounds();
+  return frame_->GetNormalBounds();
 }
 
 gfx::Rect BrowserView::GetBounds() const {
-  return frame_->GetWindow()->GetBounds();
+  return frame_->GetBounds();
 }
 
 bool BrowserView::IsMaximized() const {
-  return frame_->GetWindow()->IsMaximized();
+  return frame_->IsMaximized();
 }
 
 void BrowserView::SetFullscreen(bool fullscreen) {
   if (IsFullscreen() == fullscreen)
     return;  // Nothing to do.
 
 #if defined(OS_WIN)
   ProcessFullscreen(fullscreen);
 #else
   // On Linux changing fullscreen is async. Ask the window to change it's
   // fullscreen state, and when done invoke ProcessFullscreen.
-  frame_->GetWindow()->SetFullscreen(fullscreen);
+  frame_->SetFullscreen(fullscreen);
 #endif
 }
 
 bool BrowserView::IsFullscreen() const {
-  return frame_->GetWindow()->IsFullscreen();
+  return frame_->IsFullscreen();
 }
 
 bool BrowserView::IsFullscreenBubbleVisible() const {
   return fullscreen_bubble_.get() ? true : false;
 }
 
 void BrowserView::FullScreenStateChanged() {
   ProcessFullscreen(IsFullscreen());
 }
 
@@ skipping 187 matching lines @@
   if (UseCompactNavigationBar()) {
     return false;
   } else {
     return browser_->SupportsWindowFeature(Browser::FEATURE_TOOLBAR) ||
            browser_->SupportsWindowFeature(Browser::FEATURE_LOCATIONBAR);
   }
 }
 
 void BrowserView::DisableInactiveFrame() {
 #if defined(OS_WIN)
-  frame_->GetWindow()->DisableInactiveRendering();
+  frame_->DisableInactiveRendering();
 #endif  // No tricks are needed to get the right behavior on Linux.
 }
 
 void BrowserView::ConfirmSetDefaultSearchProvider(
     TabContents* tab_contents,
     TemplateURL* template_url,
     TemplateURLModel* template_url_model) {
 #if defined(OS_WIN)
   DefaultSearchView::Show(tab_contents, template_url, template_url_model);
 #else
@@ skipping 113 matching lines @@
     TabContentsWrapper* tab_contents) {
   browser::ShowCreateWebAppShortcutsDialog(GetNativeHandle(), tab_contents);
 }
 
 void BrowserView::ShowCreateChromeAppShortcutsDialog(Profile* profile,
                                                      const Extension* app) {
   browser::ShowCreateChromeAppShortcutsDialog(GetNativeHandle(), profile, app);
 }
 
 void BrowserView::UserChangedTheme() {
-  frame_->GetWindow()->FrameTypeChanged();
+  frame_->FrameTypeChanged();
 }
 
 int BrowserView::GetExtraRenderViewHeight() const {
   // Currently this is only used on linux.
   return 0;
 }
 
 void BrowserView::TabContentsFocused(TabContents* tab_contents) {
   contents_container_->TabContentsFocused(tab_contents);
 }
@@ skipping 464 matching lines @@
     // position of the resulting window.
     if (IsToolbarVisible()) {
       // If we're showing the toolbar, we need to adjust |*bounds| to include
       // its desired height, since the toolbar is considered part of the
       // window's client area as far as GetWindowBoundsForClientBounds is
       // concerned...
       bounds->set_height(
           bounds->height() + toolbar_->GetPreferredSize().height());
     }
 
-    gfx::Rect window_rect = frame_->GetWindow()->non_client_view()->
+    gfx::Rect window_rect = frame_->non_client_view()->
         GetWindowBoundsForClientBounds(*bounds);
     window_rect.set_origin(bounds->origin());
 
     // When we are given x/y coordinates of 0 on a created popup window,
     // assume none were given by the window.open() command.
     if (window_rect.x() == 0 && window_rect.y() == 0) {
       gfx::Size size = window_rect.size();
       window_rect.set_origin(WindowSizer::GetDefaultPopupOrigin(size));
     }
 
@@ skipping 61 matching lines @@
 
   // Give beforeunload handlers the chance to cancel the close before we hide
   // the window below.
   if (!browser_->ShouldCloseWindow())
     return false;
 
   if (!browser_->tabstrip_model()->empty()) {
     // Tab strip isn't empty.  Hide the frame (so it appears to have closed
     // immediately) and close all the tabs, allowing the renderers to shut
     // down. When the tab strip is empty we'll be called back again.
-    frame_->GetWindow()->HideWindow();
+    frame_->HideWindow();
     browser_->OnWindowClosing();
     return false;
   }
 
   // Empty TabStripModel, it's now safe to allow the Window to be closed.
   NotificationService::current()->Notify(
       NotificationType::WINDOW_CLOSED,
-      Source<gfx::NativeWindow>(frame_->GetWindow()->GetNativeWindow()),
+      Source<gfx::NativeWindow>(frame_->GetNativeWindow()),
       NotificationService::NoDetails());
   return true;
 }
 
 int BrowserView::NonClientHitTest(const gfx::Point& point) {
 #if defined(OS_WIN)
   // The following code is not in the LayoutManager because it's
   // independent of layout and also depends on the ResizeCorner which
   // is private.
-  if (!frame_->GetWindow()->IsMaximized() &&
-      !frame_->GetWindow()->IsFullscreen()) {
+  if (!frame_->IsMaximized() && !frame_->IsFullscreen()) {
     CRect client_rect;
-    ::GetClientRect(frame_->GetWindow()->GetNativeWindow(), &client_rect);
+    ::GetClientRect(frame_->GetNativeWindow(), &client_rect);
     gfx::Size resize_corner_size = ResizeCorner::GetSize();
     gfx::Rect resize_corner_rect(client_rect.right - resize_corner_size.width(),
         client_rect.bottom - resize_corner_size.height(),
         resize_corner_size.width(), resize_corner_size.height());
     bool rtl_dir = base::i18n::IsRTL();
     if (rtl_dir)
       resize_corner_rect.set_x(0);
     if (resize_corner_rect.Contains(point)) {
       if (rtl_dir)
         return HTBOTTOMLEFT;
@@ skipping 81 matching lines @@
   Layout();
 }
 
 void BrowserView::GetAccessibleState(ui::AccessibleViewState* state) {
   state->name = l10n_util::GetStringUTF16(IDS_PRODUCT_NAME);
   state->role = ui::AccessibilityTypes::ROLE_CLIENT;
 }
 
 SkColor BrowserView::GetInfoBarSeparatorColor() const {
   // NOTE: Keep this in sync with ToolbarView::OnPaint()!
-  return (IsTabStripVisible() ||
-          !frame_->GetWindow()->non_client_view()->UseNativeFrame()) ?
+  return (IsTabStripVisible() || !frame_->non_client_view()->UseNativeFrame()) ?
       ResourceBundle::toolbar_separator_color : SK_ColorBLACK;
 }
 
 void BrowserView::InfoBarContainerStateChanged(bool is_animating) {
   ToolbarSizeChanged(is_animating);
 }
 
 bool BrowserView::DrawInfoBarArrows(int* x) const {
   if (x) {
     const LocationIconView* location_icon_view =
@@ skipping 109 matching lines @@
 
   // Create a custom JumpList and add it to an observer of TabRestoreService
   // so we can update the custom JumpList when a tab is added or removed.
   if (JumpList::Enabled()) {
     jumplist_.reset(new JumpList);
     jumplist_->AddObserver(browser_->profile());
   }
 
   if (AeroPeekManager::Enabled()) {
     aeropeek_manager_.reset(new AeroPeekManager(
-        frame_->GetWindow()->GetNativeWindow()));
+        frame_->GetNativeWindow()));
     browser_->tabstrip_model()->AddObserver(aeropeek_manager_.get());
   }
 #endif
   // Only create our compact navigation classes if the switch is enabled. Note
   // that we directly check the switch and not the pref as the switch may be on
   // and the pref could be off (currently not selected in the context menu).
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableCompactNavigation)) {
     compact_location_bar_view_host_.reset(new CompactLocationBarViewHost(this));
     compact_navigation_bar_ = new CompactNavigationBar(this);
@@ skipping 47 matching lines @@
 void BrowserView::InitSystemMenu() {
   system_menu_contents_.reset(new views::SystemMenuModel(this));
   // We add the menu items in reverse order so that insertion_index never needs
   // to change.
   if (IsBrowserTypeNormal())
     BuildSystemMenuForBrowserWindow();
   else
     BuildSystemMenuForAppOrPopupWindow();
   system_menu_.reset(
       new views::NativeMenuWin(system_menu_contents_.get(),
-                               frame_->GetWindow()->GetNativeWindow()));
+                               frame_->GetNativeWindow()));
   system_menu_->Rebuild();
 }
 #endif
 
 BrowserViewLayout* BrowserView::GetBrowserViewLayout() const {
   return static_cast<BrowserViewLayout*>(GetLayoutManager());
 }
 
 void BrowserView::LayoutStatusBubble() {
   // In restored mode, the client area has a client edge between it and the
@@ skipping 231 matching lines @@
     // If we don't hide the edit and force it to not show until we come out of
     // fullscreen, then if the user was on the New Tab Page, the edit contents
     // will appear atop the web contents once we go into fullscreen mode.  This
     // has something to do with how we move the main window while it's hidden;
     // if we don't hide the main window below, we don't get this problem.
     omnibox_view->set_force_hidden(true);
     ShowWindow(omnibox_view->m_hWnd, SW_HIDE);
 #endif
   }
 #if defined(OS_WIN)
-  static_cast<views::WindowWin*>(
-      frame_->GetWindow()->native_window())->PushForceHidden();
+  static_cast<views::WindowWin*>(frame_->native_window())->PushForceHidden();
 #endif
 
   // Notify bookmark bar, so it can set itself to the appropriate drawing state.
   if (bookmark_bar_view_.get())
     bookmark_bar_view_->OnFullscreenToggled(fullscreen);
 
   // Toggle fullscreen mode.
 #if defined(OS_WIN)
-  frame_->GetWindow()->SetFullscreen(fullscreen);
+  frame_->SetFullscreen(fullscreen);
 #endif  // No need to invoke SetFullscreen for linux as this code is executed
         // once we're already fullscreen on linux.
 
 #if defined(TOOLKIT_USES_GTK)
   // Updating of commands for fullscreen mode is called from SetFullScreen on
   // Wndows (see just above), but for ChromeOS, this method (ProcessFullScreen)
   // is called after full screen has happened successfully (via GTK's
   // window-state-change event), so we have to update commands here.
   browser_->UpdateCommandsForFullscreenMode(fullscreen);
 #endif
@@ skipping 11 matching lines @@
     omnibox_view->set_force_hidden(false);
     ShowWindow(omnibox_view->m_hWnd, SW_SHOW);
 #endif
   }
 
   // Undo our anti-jankiness hacks and force the window to relayout now that
   // it's in its final position.
   ignore_layout_ = false;
   Layout();
 #if defined(OS_WIN)
-  static_cast<views::WindowWin*>(
-      frame_->GetWindow()->native_window())->PopForceHidden();
+  static_cast<views::WindowWin*>(frame_->native_window())->PopForceHidden();
 #endif
 }
 
 
 void BrowserView::LoadAccelerators() {
 #if defined(OS_WIN)
   HACCEL accelerator_table = AtlLoadAccelerators(IDR_MAINFRAME);
   DCHECK(accelerator_table);
 
   // We have to copy the table to access its contents.
@@ skipping 262 matching lines @@
     toolbar_->Init(browser_->profile());
   }
 }
 
 #if !defined(OS_CHROMEOS)
 // static
 BrowserWindow* BrowserWindow::CreateBrowserWindow(Browser* browser) {
   // Create the view and the frame. The frame will attach itself via the view
   // so we don't need to do anything with the pointer.
   BrowserView* view = new BrowserView(browser);
-  BrowserFrame::Create(view, browser->profile());
-
+  (new BrowserFrame(view))->InitBrowserFrame();
   view->GetWindow()->non_client_view()->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_PRODUCT_NAME));
-
   return view;
 }
 #endif
 
 // static
 FindBar* BrowserWindow::CreateFindBar(Browser* browser) {
   return browser::CreateFindBar(static_cast<BrowserView*>(browser->window()));
 }