Add split with devtools container into the browser view.

chrome/browser/views/frame/browser_view.cc

 // Copyright (c) 2006-2009 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/views/frame/browser_view.h"
 
 #if defined(OS_LINUX)
 #include <gtk/gtk.h>
 #endif
 
 #include "app/drag_drop_types.h"
 #include "app/gfx/canvas.h"
 #include "app/l10n_util.h"
 #include "app/os_exchange_data.h"
 #include "app/resource_bundle.h"
 #include "base/command_line.h"
 #include "base/time.h"
 #include "build/build_config.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/app_modal_dialog_queue.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/debugger/devtools_window.h"
 #include "chrome/browser/download/download_manager.h"
 #include "chrome/browser/find_bar.h"
 #include "chrome/browser/find_bar_controller.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/view_ids.h"
 #include "chrome/browser/views/bookmark_bar_view.h"
 #include "chrome/browser/views/browser_bubble.h"
 #include "chrome/browser/views/browser_dialogs.h"
 #include "chrome/browser/views/chrome_views_delegate.h"
 #include "chrome/browser/views/download_shelf_view.h"
@@ skipping 17 matching lines @@
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "grit/app_resources.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/webkit_resources.h"
 #if defined(OS_WIN)
 #include "views/controls/scrollbar/native_scroll_bar.h"
 #endif
+#include "views/controls/single_split_view.h"
 #include "views/fill_layout.h"
 #include "views/view.h"
 #include "views/widget/root_view.h"
 #include "views/window/dialog_delegate.h"
 #if !defined(OS_WIN)
 #include "views/window/hit_test.h"
 #endif
 #include "views/window/non_client_view.h"
 #include "views/window/window.h"
 
@@ skipping 198 matching lines @@
 BrowserView::BrowserView(Browser* browser)
     : views::ClientView(NULL, NULL),
       frame_(NULL),
       browser_(browser),
       active_bookmark_bar_(NULL),
       tabstrip_(NULL),
       toolbar_(NULL),
       infobar_container_(NULL),
       find_bar_y_(0),
       contents_container_(NULL),
+      devtools_container_(NULL),
+      contents_split_(NULL),
       initialized_(false),
       ignore_layout_(false),
 #if defined(OS_WIN)
       hung_window_detector_(&hung_plugin_action_),
       ticker_(0),
 #endif
       extension_shelf_(NULL) {
   InitClass();
   browser_->tabstrip_model()->AddObserver(this);
 }
@@ skipping 237 matching lines @@
   system_menu_->UpdateStates();
 }
 #endif
 
 // static
 void BrowserView::RegisterBrowserViewPrefs(PrefService* prefs) {
   prefs->RegisterIntegerPref(prefs::kPluginMessageResponseTimeout,
                              kDefaultPluginMessageResponseTimeout);
   prefs->RegisterIntegerPref(prefs::kHungPluginDetectFrequency,
                              kDefaultHungPluginDetectFrequency);
+  prefs->RegisterIntegerPref(prefs::kDevToolsSplitLocation, -1);
 }
 
 void BrowserView::AttachBrowserBubble(BrowserBubble* bubble) {
   browser_bubbles_.insert(bubble);
 }
 
 void BrowserView::DetachBrowserBubble(BrowserBubble* bubble) {
   BubbleSet::iterator it = browser_bubbles_.find(bubble);
   if (it != browser_bubbles_.end())
     browser_bubbles_.erase(it);
@@ skipping 16 matching lines @@
   // 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.
   TabContents* selected_tab_contents = GetSelectedTabContents();
   if (selected_tab_contents)
     selected_tab_contents->view()->RestoreFocus();
 
+  // Restore split offset.
+  int split_offset = g_browser_process->local_state()->GetInteger(
+      prefs::kDevToolsSplitLocation);
+  if (split_offset == -1) {
+    // 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);
+
   frame_->GetWindow()->Show();
 }
 
 void BrowserView::SetBounds(const gfx::Rect& bounds) {
   GetWidget()->SetBounds(bounds);
 }
 
 void BrowserView::Close() {
   frame_->GetWindow()->Close();
 
   BubbleSet::iterator bubble = browser_bubbles_.begin();
   for (; bubble != browser_bubbles_.end(); ++bubble) {
     (*bubble)->BrowserWindowClosed();
   }
+
+  g_browser_process->local_state()->SetInteger(
+      prefs::kDevToolsSplitLocation, contents_split_->divider_offset());
 }
 
 void BrowserView::Activate() {
   frame_->GetWindow()->Activate();
 }
 
 bool BrowserView::IsActive() const {
   return frame_->GetWindow()->IsActive();
 }
 
@@ skipping 27 matching lines @@
 #endif
 }
 
 void BrowserView::SelectedTabToolbarSizeChanged(bool is_animating) {
   if (is_animating) {
     contents_container_->SetFastResize(true);
     UpdateUIForContents(browser_->GetSelectedTabContents());
     contents_container_->SetFastResize(false);
   } else {
     UpdateUIForContents(browser_->GetSelectedTabContents());
-    contents_container_->Layout();
+    contents_split_->Layout();
   }
 }
 
 void BrowserView::UpdateTitleBar() {
   frame_->GetWindow()->UpdateWindowTitle();
   if (ShouldShowWindowIcon())
     frame_->GetWindow()->UpdateWindowIcon();
 }
 
 void BrowserView::UpdateDevTools() {
-  NOTIMPLEMENTED();
+  UpdateDevToolsForContents(GetSelectedTabContents());
+  Layout();
 }
 
 void BrowserView::UpdateLoadingAnimations(bool should_animate) {
   if (should_animate) {
     if (!loading_animation_timer_.IsRunning()) {
       // Loads are happening, and the timer isn't running, so start it.
       loading_animation_timer_.Start(
           TimeDelta::FromMilliseconds(kLoadingAnimationFrameTimeMs), this,
           &BrowserView::LoadingAnimationCallback);
     }
@@ skipping 137 matching lines @@
 
   // We don't specify a resize corner size if we have a bottom shelf either.
   // This is because we take care of drawing the resize corner on top of that
   // shelf, so we don't want others to do it for us in this case.
   // Currently, the only visible bottom shelf is the download shelf.
   // Other tests should be added here if we add more bottom shelves.
   if (download_shelf_.get() && download_shelf_->IsShowing()) {
     return gfx::Rect();
   }
 
-  gfx::Rect client_rect = contents_container_->bounds();
+  gfx::Rect client_rect = contents_split_->bounds();
   gfx::Size resize_corner_size = ResizeCorner::GetSize();
   int x = client_rect.width() - resize_corner_size.width();
   if (l10n_util::GetTextDirection() == l10n_util::RIGHT_TO_LEFT)
     x = 0;
   return gfx::Rect(x, client_rect.height() - resize_corner_size.height(),
                    resize_corner_size.width(), resize_corner_size.height());
 }
 
 void BrowserView::DisableInactiveFrame() {
   frame_->GetWindow()->DisableInactiveRendering();
@@ skipping 158 matching lines @@
 void BrowserView::TabDetachedAt(TabContents* contents, int index) {
   // We use index here rather than comparing |contents| because by this time
   // the model has already removed |contents| from its list, so
   // browser_->GetSelectedTabContents() will return NULL or something else.
   if (index == browser_->tabstrip_model()->selected_index()) {
     // We need to reset the current tab contents to NULL before it gets
     // freed. This is because the focus manager performs some operations
     // on the selected TabContents when it is removed.
     infobar_container_->ChangeTabContents(NULL);
     contents_container_->ChangeTabContents(NULL);
+    UpdateDevToolsForContents(NULL);
   }
 }
 
 void BrowserView::TabDeselectedAt(TabContents* contents, int index) {
   // We do not store the focus when closing the tab to work-around bug 4633.
   // Some reports seem to show that the focus manager and/or focused view can
   // be garbage at that point, it is not clear why.
   if (!contents->is_being_destroyed())
     contents->view()->StoreFocus();
 }
 
 void BrowserView::TabSelectedAt(TabContents* old_contents,
                                 TabContents* new_contents,
                                 int index,
                                 bool user_gesture) {
   DCHECK(old_contents != new_contents);
 
   // Update various elements that are interested in knowing the current
   // TabContents.
   infobar_container_->ChangeTabContents(new_contents);
   contents_container_->ChangeTabContents(new_contents);
+  UpdateDevToolsForContents(new_contents);
   // TODO(beng): This should be called automatically by ChangeTabContents, but I
   //             am striving for parity now rather than cleanliness. This is
   //             required to make features like Duplicate Tab, Undo Close Tab,
   //             etc not result in sad tab.
   new_contents->DidBecomeSelected();
   if (BrowserList::GetLastActive() == browser_ &&
       !browser_->tabstrip_model()->closing_all() && GetWindow()->IsVisible()) {
     // We only restore focus if our window is visible, to avoid invoking blur
     // handlers when we are eventually shown.
     new_contents->view()->RestoreFocus();
@@ skipping 302 matching lines @@
       toolbar_->GetMinimumSize() : gfx::Size());
   if (tabstrip_size.height() && toolbar_size.height())
     toolbar_size.Enlarge(0, -kToolbarTabStripVerticalOverlap);
   gfx::Size bookmark_bar_size;
   if (active_bookmark_bar_ &&
       browser_->SupportsWindowFeature(Browser::FEATURE_BOOKMARKBAR)) {
     bookmark_bar_size = active_bookmark_bar_->GetMinimumSize();
     bookmark_bar_size.Enlarge(0,
         -kSeparationLineHeight - bookmark_bar_view_->GetToolbarOverlap(true));
   }
-  gfx::Size contents_size(contents_container_->GetMinimumSize());
+  gfx::Size contents_size(contents_split_->GetMinimumSize());
 
   int min_height = tabstrip_size.height() + toolbar_size.height() +
       bookmark_bar_size.height() + contents_size.height();
   int widths[] = { tabstrip_size.width(), toolbar_size.width(),
                    bookmark_bar_size.width(), contents_size.width() };
   int min_width = *std::max_element(&widths[0], &widths[arraysize(widths)]);
   return gfx::Size(min_width, min_height);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 69 matching lines @@
   AddChildView(toolbar_);
   toolbar_->SetID(VIEW_ID_TOOLBAR);
   toolbar_->Init(browser_->profile());
   toolbar_->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_TOOLBAR));
 
   infobar_container_ = new InfoBarContainer(this);
   AddChildView(infobar_container_);
 
   contents_container_ = new TabContentsContainer;
   set_contents_view(contents_container_);
-  AddChildView(contents_container_);
+
+  devtools_container_ = new TabContentsContainer;
+  contents_split_ = new views::SingleSplitView(
+      contents_container_,
+      devtools_container_,
+      views::SingleSplitView::VERTICAL_SPLIT);
+
+  AddChildView(contents_split_);
 
   status_bubble_.reset(new StatusBubbleViews(GetWidget()));
 
   extension_shelf_ = new ExtensionShelf(browser_.get());
   AddChildView(extension_shelf_);
 
 #if defined(OS_WIN)
   InitSystemMenu();
 #endif
 }
@@ skipping 74 matching lines @@
 
 int BrowserView::LayoutInfoBar(int top) {
   bool visible = browser_->SupportsWindowFeature(Browser::FEATURE_INFOBAR);
   int height = visible ? infobar_container_->GetPreferredSize().height() : 0;
   infobar_container_->SetVisible(visible);
   infobar_container_->SetBounds(0, top, width(), height);
   return top + height;
 }
 
 void BrowserView::LayoutTabContents(int top, int bottom) {
-  contents_container_->SetBounds(0, top, width(), bottom - top);
+  contents_split_->SetBounds(0, top, width(), bottom - top);
 }
 
 int BrowserView::LayoutDownloadShelf(int bottom) {
   if (IsDownloadShelfVisible()) {
     bool visible = browser_->SupportsWindowFeature(
         Browser::FEATURE_DOWNLOADSHELF);
     DCHECK(download_shelf_.get());
     int height = visible ? download_shelf_->GetPreferredSize().height() : 0;
     download_shelf_->SetVisible(visible);
     download_shelf_->SetBounds(0, bottom - height, width(), height);
@@ skipping 46 matching lines @@
   return UpdateChildViewAndLayout(new_bookmark_bar_view, &active_bookmark_bar_);
 }
 
 bool BrowserView::MaybeShowInfoBar(TabContents* contents) {
   // TODO(beng): Remove this function once the interface between
   //             InfoBarContainer, DownloadShelfView and TabContents and this
   //             view is sorted out.
   return true;
 }
 
+void BrowserView::UpdateDevToolsForContents(TabContents* tab_contents) {
+  TabContents* devtools_contents =
+      DevToolsWindow::GetDevToolsContents(tab_contents);
+  devtools_container_->ChangeTabContents(devtools_contents);
+  devtools_container_->SetVisible(devtools_contents != NULL);
+}
+
 void BrowserView::UpdateUIForContents(TabContents* contents) {
   bool needs_layout = MaybeShowBookmarkBar(contents);
   needs_layout |= MaybeShowInfoBar(contents);
   if (needs_layout)
     Layout();
 }
 
 bool BrowserView::UpdateChildViewAndLayout(views::View* new_view,
                                            views::View** old_view) {
   DCHECK(old_view);
@@ skipping 225 matching lines @@
 
 // static
 FindBar* BrowserWindow::CreateFindBar(Browser* browser) {
   return browser::CreateFindBar(static_cast<BrowserView*>(browser->window()));
 }
 
 // static
 void BrowserList::AllBrowsersClosed() {
   views::Window::CloseAllSecondaryWindows();
 }