Revert 71230 to see if it is related to hang on linux interactive_ui_tests....

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(OS_LINUX)
 #include <gtk/gtk.h>
 #endif
 
@@ skipping 1330 matching lines @@
 void BrowserView::ToggleTabStripMode() {
   InitTabStrip(browser_->tabstrip_model());
   frame_->TabStripDisplayModeChanged();
 }
 
 void BrowserView::PrepareForInstant() {
   contents_->FadeActiveContents();
 }
 
 void BrowserView::ShowInstant(TabContents* preview_contents) {
-  if (!preview_container_)
+  if (!preview_container_) {
     preview_container_ = new TabContentsContainer();
+    preview_container_->set_reserved_area_delegate(this);
+  }
   contents_->SetPreview(preview_container_, preview_contents);
   preview_container_->ChangeTabContents(preview_contents);
 
 #if defined(OS_WIN)
   // Removing the fade is instant (on windows). We need to force the preview to
   // draw, otherwise the current page flickers before the new page appears.
   RedrawWindow(preview_contents->view()->GetContentNativeView(), NULL, NULL,
                RDW_INVALIDATE | RDW_UPDATENOW | RDW_NOCHILDREN);
 #endif
 
@@ skipping 453 matching lines @@
 }
 
 AccessibilityTypes::Role BrowserView::GetAccessibleRole() {
   return AccessibilityTypes::ROLE_CLIENT;
 }
 
 void BrowserView::InfoBarSizeChanged(bool is_animating) {
   SelectedTabToolbarSizeChanged(is_animating);
 }
 
-bool BrowserView::SplitHandleMoved(views::SingleSplitView* view) {
-  for (int i = 0; i < view->GetChildViewCount(); ++i)
-    view->GetChildViewAt(i)->InvalidateLayout();
-  SchedulePaint();
-  Layout();
-  return false;
+void BrowserView::UpdateReservedContentsRect(
+    const TabContentsContainer* source) {
+  RenderWidgetHostView* render_widget_host_view =
+      source->tab_contents() ? source->tab_contents()->GetRenderWidgetHostView()
+                             : NULL;
+  if (!render_widget_host_view)
+    return;
+
+  gfx::Rect reserved_rect;
+
+  if (!frame_->GetWindow()->IsMaximized() &&
+      !frame_->GetWindow()->IsFullscreen()) {
+    gfx::Size resize_corner_size = ResizeCorner::GetSize();
+    if (!resize_corner_size.IsEmpty()) {
+      gfx::Point resize_corner_origin;
+      gfx::Rect bounds = GetLocalBounds(false);
+      resize_corner_origin.set_x(bounds.right() - resize_corner_size.width());
+      resize_corner_origin.set_y(bounds.bottom() - resize_corner_size.height());
+
+      View::ConvertPointToView(this, source, &resize_corner_origin);
+
+      gfx::Size container_size = source->size();
+
+      if (resize_corner_origin.x() < container_size.width() &&
+          resize_corner_origin.y() < container_size.height()) {
+        reserved_rect = gfx::Rect(resize_corner_origin, resize_corner_size);
+      }
+    }
+  }
+
+  // TODO(alekseys): for source == contents_container_, consult SidebarTabView
+  // for the current size to reserve. Something like this:
+  // reserved_rect = reserved_rect.Union(SidebarTabView::GetCurrentBounds());
+
+  render_widget_host_view->set_reserved_contents_rect(reserved_rect);
 }
 
 views::LayoutManager* BrowserView::CreateLayoutManager() const {
   return new BrowserViewLayout;
 }
 
 void BrowserView::InitTabStrip(TabStripModel* model) {
   // Throw away the existing tabstrip if we're switching display modes.
   scoped_ptr<BaseTabStrip> old_strip(tabstrip_);
   if (tabstrip_) {
@@ skipping 42 matching lines @@
   toolbar_ = new ToolbarView(browser_.get());
   AddChildView(toolbar_);
   toolbar_->Init(browser_->profile());
   toolbar_->SetAccessibleName(
       UTF16ToWide(l10n_util::GetStringUTF16(IDS_ACCNAME_TOOLBAR)));
 
   infobar_container_ = new InfoBarContainer(this);
   AddChildView(infobar_container_);
 
   contents_container_ = new TabContentsContainer;
+  contents_container_->set_reserved_area_delegate(this);
   contents_ = new ContentsContainer(contents_container_);
 
   SkColor bg_color = GetWidget()->GetThemeProvider()->
       GetColor(BrowserThemeProvider::COLOR_TOOLBAR);
 
   bool sidebar_allowed = SidebarManager::IsSidebarAllowed();
   if (sidebar_allowed) {
     sidebar_container_ = new TabContentsContainer;
+    sidebar_container_->set_reserved_area_delegate(this);
     sidebar_container_->SetID(VIEW_ID_SIDE_BAR_CONTAINER);
     sidebar_container_->SetVisible(false);
 
     sidebar_split_ = new views::SingleSplitView(
         contents_,
         sidebar_container_,
-        views::SingleSplitView::HORIZONTAL_SPLIT,
-        this);
+        views::SingleSplitView::HORIZONTAL_SPLIT);
     sidebar_split_->SetID(VIEW_ID_SIDE_BAR_SPLIT);
     sidebar_split_->SetAccessibleName(
         UTF16ToWide(l10n_util::GetStringUTF16(IDS_ACCNAME_SIDE_BAR)));
     sidebar_split_->set_background(
         views::Background::CreateSolidBackground(bg_color));
   }
 
   devtools_container_ = new TabContentsContainer;
+  devtools_container_->set_reserved_area_delegate(this);
   devtools_container_->SetID(VIEW_ID_DEV_TOOLS_DOCKED);
   devtools_container_->SetVisible(false);
 
   views::View* contents_view = contents_;
   if (sidebar_allowed)
     contents_view = sidebar_split_;
 
   contents_split_ = new views::SingleSplitView(
       contents_view,
       devtools_container_,
-      views::SingleSplitView::VERTICAL_SPLIT,
-      this);
+      views::SingleSplitView::VERTICAL_SPLIT);
   contents_split_->SetID(VIEW_ID_CONTENTS_SPLIT);
   contents_split_->SetAccessibleName(
       UTF16ToWide(l10n_util::GetStringUTF16(IDS_ACCNAME_WEB_CONTENTS)));
   contents_split_->set_background(
       views::Background::CreateSolidBackground(bg_color));
   AddChildView(contents_split_);
   set_contents_view(contents_split_);
 
   status_bubble_.reset(new StatusBubbleViews(contents_));
 
@@ skipping 123 matching lines @@
     }
     // Make sure user can see both panes.
     int min_sidebar_width = sidebar_split_->GetMinimumSize().width();
     sidebar_width = std::min(sidebar_split_->width() - min_sidebar_width,
                              std::max(min_sidebar_width, sidebar_width));
 
     sidebar_split_->set_divider_offset(
         sidebar_split_->width() - sidebar_width);
 
     sidebar_container_->SetVisible(true);
-    sidebar_split_->InvalidateLayout();
-    Layout();
+    sidebar_split_->Layout();
   } else if (should_hide) {
     // Store split offset when hiding sidebar only.
     g_browser_process->local_state()->SetInteger(
         prefs::kExtensionSidebarWidth,
         sidebar_split_->width() - sidebar_split_->divider_offset());
 
     sidebar_container_->SetVisible(false);
-    sidebar_split_->InvalidateLayout();
-    Layout();
+    sidebar_split_->Layout();
   }
 }
 
 void BrowserView::UpdateDevToolsForContents(TabContentsWrapper* wrapper) {
   TabContents* tab_contents = wrapper ? wrapper->tab_contents() : NULL;
   TabContents* devtools_contents =
       DevToolsWindow::GetDevToolsContents(tab_contents);
 
   bool should_show = devtools_contents && !devtools_container_->IsVisible();
   bool should_hide = !devtools_contents && devtools_container_->IsVisible();
@@ skipping 16 matching lines @@
       // Initial load, set to default value.
       split_offset = 2 * contents_split_->height() / 3;
     }
     // Make sure user can see both panes.
     int min_split_size = contents_split_->height() / 10;
     split_offset = std::min(contents_split_->height() - min_split_size,
                             std::max(min_split_size, split_offset));
     contents_split_->set_divider_offset(split_offset);
 
     devtools_container_->SetVisible(true);
-    contents_split_->InvalidateLayout();
-    Layout();
+    contents_split_->Layout();
   } else if (should_hide) {
     // Store split offset when hiding devtools window only.
     g_browser_process->local_state()->SetInteger(
         prefs::kDevToolsSplitLocation, contents_split_->divider_offset());
 
     // Restore focus to the last focused view when hiding devtools window.
     devtools_focus_tracker_->FocusLastFocusedExternalView();
 
     devtools_container_->SetVisible(false);
-    contents_split_->InvalidateLayout();
-    Layout();
+    contents_split_->Layout();
   }
 }
 
 void BrowserView::UpdateUIForContents(TabContentsWrapper* contents) {
   bool needs_layout = MaybeShowBookmarkBar(contents);
   needs_layout |= MaybeShowInfoBar(contents);
   if (needs_layout)
     Layout();
 }
 
@@ skipping 389 matching lines @@
     // handlers when we are eventually shown.
     new_contents->view()->RestoreFocus();
   }
 
   // Update all the UI bits.
   UpdateTitleBar();
   UpdateToolbar(new_contents, true);
   UpdateUIForContents(new_contents);
 }
 
-gfx::Size BrowserView::GetResizeCornerSize() const {
-  return ResizeCorner::GetSize();
-}
-
 #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());
 
   view->GetWindow()->GetNonClientView()->SetAccessibleName(
       UTF16ToWide(l10n_util::GetStringUTF16(IDS_PRODUCT_NAME)));
 
   return view;
 }
 #endif
 
 // static
 FindBar* BrowserWindow::CreateFindBar(Browser* browser) {
   return browser::CreateFindBar(static_cast<BrowserView*>(browser->window()));
 }