Compact Navigation prototype

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 23 matching lines @@
 #include "chrome/browser/sessions/tab_restore_service_factory.h"
 #include "chrome/browser/sidebar/sidebar_container.h"
 #include "chrome/browser/sidebar/sidebar_manager.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/themes/theme_service.h"
 #include "chrome/browser/ui/app_modal_dialogs/app_modal_dialog_queue.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/ui/tabs/tab_menu_model.h"
 #include "chrome/browser/ui/toolbar/wrench_menu_model.h"
 #include "chrome/browser/ui/view_ids.h"
 #include "chrome/browser/ui/views/bookmarks/bookmark_bar_view.h"
 #include "chrome/browser/ui/views/browser_dialogs.h"
+#include "chrome/browser/ui/views/compact_nav/compact_location_bar_view.h"
+#include "chrome/browser/ui/views/compact_nav/compact_location_bar_view_host.h"
+#include "chrome/browser/ui/views/compact_nav/compact_navigation_bar.h"
+#include "chrome/browser/ui/views/compact_nav/compact_options_bar.h"
 #include "chrome/browser/ui/views/default_search_view.h"
 #include "chrome/browser/ui/views/download/download_in_progress_dialog_view.h"
 #include "chrome/browser/ui/views/download/download_shelf_view.h"
 #include "chrome/browser/ui/views/frame/browser_view_layout.h"
 #include "chrome/browser/ui/views/frame/contents_container.h"
 #include "chrome/browser/ui/views/fullscreen_exit_bubble.h"
 #include "chrome/browser/ui/views/infobars/infobar_container_view.h"
 #include "chrome/browser/ui/views/location_bar/location_icon_view.h"
 #include "chrome/browser/ui/views/status_bubble_views.h"
 #include "chrome/browser/ui/views/tab_contents/tab_contents_container.h"
@@ skipping 13 matching lines @@
 #include "content/browser/renderer_host/render_widget_host_view.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/tab_contents/tab_contents_view.h"
 #include "content/browser/user_metrics.h"
 #include "content/common/notification_service.h"
 #include "grit/app_resources.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "grit/theme_resources.h"
+#include "grit/theme_resources_standard.h"
 #include "grit/webkit_resources.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas_skia.h"
 #include "views/controls/single_split_view.h"
 #include "views/events/event.h"
 #include "views/focus/external_focus_tracker.h"
 #include "views/focus/view_storage.h"
 #include "views/layout/grid_layout.h"
@@ skipping 206 matching lines @@
 
 BrowserView::BrowserView(Browser* browser)
     : views::ClientView(NULL, NULL),
       last_focused_view_storage_id_(
           views::ViewStorage::GetInstance()->CreateStorageID()),
       frame_(NULL),
       browser_(browser),
       active_bookmark_bar_(NULL),
       tabstrip_(NULL),
       toolbar_(NULL),
+      compact_navigation_bar_(NULL),
+      compact_options_bar_(NULL),
+      compact_spacer_(NULL),
       infobar_container_(NULL),
       sidebar_container_(NULL),
       sidebar_split_(NULL),
       contents_container_(NULL),
       devtools_container_(NULL),
       preview_container_(NULL),
       contents_(NULL),
       contents_split_(NULL),
       initialized_(false),
       ignore_layout_(true)
@@ skipping 54 matching lines @@
   if (window) {
     return static_cast<BrowserView*>(
         g_object_get_data(G_OBJECT(window), kBrowserViewKey));
   }
 #endif
   return NULL;
 }
 
 gfx::Rect BrowserView::GetToolbarBounds() const {
   gfx::Rect toolbar_bounds(toolbar_->bounds());
+  // In compact navigation mode, the spacer essentially replaces the toolbar.
+  // We must provide it's height in order to have the client area divider paint
+  // properly.
+  if (UseCompactNavigationBar())
+    toolbar_bounds = compact_spacer_->bounds();
   if (toolbar_bounds.IsEmpty())
     return toolbar_bounds;
   // When using vertical tabs, the toolbar appears to extend behind the tab
   // column.
   if (UseVerticalTabs())
     toolbar_bounds.Inset(tabstrip_->x() - toolbar_bounds.x(), 0, 0, 0);
   // The apparent toolbar edges are outside the "real" toolbar edges.
   toolbar_bounds.Inset(-views::NonClientFrameView::kClientEdgeThickness, 0);
   return toolbar_bounds;
 }
 
 gfx::Rect BrowserView::GetClientAreaBounds() const {
   gfx::Rect container_bounds = contents_->bounds();
   gfx::Point container_origin = container_bounds.origin();
   ConvertPointToView(this, parent(), &container_origin);
   container_bounds.set_origin(container_origin);
   return container_bounds;
 }
 
 gfx::Rect BrowserView::GetFindBarBoundingBox() const {
   return GetBrowserViewLayout()->GetFindBarBoundingBox();
 }
 
+gfx::Rect BrowserView::GetCompactNavigationBarBounds() const {
+  return compact_navigation_bar_->bounds();
+}
+
+gfx::Rect BrowserView::GetCompactOptionsBarBounds() const {
+  return compact_options_bar_->bounds();
+}
+
 int BrowserView::GetTabStripHeight() const {
   // We want to return tabstrip_->height(), but we might be called in the midst
   // of layout, when that hasn't yet been updated to reflect the current state.
   // So return what the tabstrip height _ought_ to be right now.
   return IsTabStripVisible() ? tabstrip_->GetPreferredSize().height() : 0;
 }
 
 gfx::Point BrowserView::OffsetPointForToolbarBackgroundImage(
     const gfx::Point& point) const {
   // The background image starts tiling horizontally at the window left edge and
@@ skipping 11 matching lines @@
 }
 
 bool BrowserView::IsTabStripVisible() const {
   return browser_->SupportsWindowFeature(Browser::FEATURE_TABSTRIP);
 }
 
 bool BrowserView::UseVerticalTabs() const {
   return browser_->tabstrip_model()->delegate()->UseVerticalTabs();
 }
 
+bool BrowserView::UseCompactNavigationBar() const {
+  return browser_->tabstrip_model()->delegate()->UseCompactNavigationBar();
+}
+
 bool BrowserView::IsOffTheRecord() const {
   return browser_->profile()->IsOffTheRecord();
 }
 
 bool BrowserView::ShouldShowOffTheRecordAvatar() const {
   return IsOffTheRecord() && IsBrowserTypeNormal();
 }
 
 bool BrowserView::AcceleratorPressed(const views::Accelerator& accelerator) {
 #if defined(OS_CHROMEOS)
@@ skipping 255 matching lines @@
     if (loading_animation_timer_.IsRunning()) {
       last_animation_time_ = base::TimeTicks();
       loading_animation_timer_.Stop();
       // Loads are now complete, update the state if a task was scheduled.
       LoadingAnimationCallback();
     }
   }
 }
 
 void BrowserView::SetStarredState(bool is_starred) {
-  toolbar_->location_bar()->SetStarToggled(is_starred);
+  GetLocationBarView()->SetStarToggled(is_starred);
 }
 
 gfx::Rect BrowserView::GetRestoredBounds() const {
   return frame_->GetWindow()->GetNormalBounds();
 }
 
 gfx::Rect BrowserView::GetBounds() const {
   return frame_->GetWindow()->GetBounds();
 }
 
@@ skipping 26 matching lines @@
   ProcessFullscreen(IsFullscreen());
 }
 
 void BrowserView::RestoreFocus() {
   TabContents* selected_tab_contents = GetSelectedTabContents();
   if (selected_tab_contents)
     selected_tab_contents->view()->RestoreFocus();
 }
 
 LocationBar* BrowserView::GetLocationBar() const {
-  return toolbar_->location_bar();
+  return GetLocationBarView();
 }
 
 void BrowserView::SetFocusToLocationBar(bool select_all) {
-  LocationBarView* location_bar = toolbar_->location_bar();
+  if (UseCompactNavigationBar()) {
+    // If focus ever goes to the location bar, we should make sure it is shown
+    // in compact mode. This includes all accelerators that move focus there.
+    ShowCompactLocationBarUnderSelectedTab();
+  }
+  LocationBarView* location_bar = GetLocationBarView();
   if (location_bar->IsFocusableInRootView()) {
     // Location bar got focus.
     location_bar->FocusLocation(select_all);
   } else {
     // If none of location bar/compact navigation bar got focus,
     // then clear focus.
     views::FocusManager* focus_manager = GetFocusManager();
     DCHECK(focus_manager);
     focus_manager->ClearFocus();
   }
 }
 
 void BrowserView::UpdateReloadStopState(bool is_loading, bool force) {
-  toolbar_->reload_button()->ChangeMode(
+  ReloadButton* reload_button = NULL;
+  if (UseCompactNavigationBar()) {
+    reload_button = compact_location_bar_view_host_->
+        GetCompactLocationBarView()->reload_button();
+  } else {
+    reload_button = toolbar_->reload_button();
+  }
+  reload_button->ChangeMode(
       is_loading ? ReloadButton::MODE_STOP : ReloadButton::MODE_RELOAD, force);
 }
 
 void BrowserView::UpdateToolbar(TabContentsWrapper* contents,
                                 bool should_restore_state) {
-  toolbar_->Update(contents->tab_contents(), should_restore_state);
+  if (UseCompactNavigationBar()) {
+    if (compact_location_bar_view_host_->IsVisible()) {
+      compact_location_bar_view_host_->Update(
+          should_restore_state ? contents->tab_contents() : NULL, true);
+    }
+  } else {
+    toolbar_->Update(contents->tab_contents(), should_restore_state);
+  }
 }
 
 void BrowserView::FocusToolbar() {
   // Start the traversal within the main toolbar, passing it the storage id
   // of the view where focus should be returned if the user exits the toolbar.
   SaveFocusedView();
-  toolbar_->SetPaneFocus(last_focused_view_storage_id_, NULL);
+  if (UseCompactNavigationBar()) {
+    if (!compact_location_bar_view_host_->IsVisible())
+      compact_location_bar_view_host_->UpdateOnTabChange(
+          browser()->active_index(), true);
+    compact_location_bar_view_host_->GetCompactLocationBarView()->SetPaneFocus(
+        last_focused_view_storage_id_, NULL);
+  } else {
+    toolbar_->SetPaneFocus(last_focused_view_storage_id_, NULL);
+  }
 }
 
 void BrowserView::FocusBookmarksToolbar() {
   if (active_bookmark_bar_ && bookmark_bar_view_->IsVisible()) {
     SaveFocusedView();
     bookmark_bar_view_->SetPaneFocus(last_focused_view_storage_id_, NULL);
   }
 }
 
 void BrowserView::FocusAppMenu() {
   // Chrome doesn't have a traditional menu bar, but it has a menu button in the
   // main toolbar that plays the same role.  If the user presses a key that
   // would typically focus the menu bar, tell the toolbar to focus the menu
   // button.  If the user presses the key again, return focus to the previous
   // location.
   //
   // Not used on the Mac, which has a normal menu bar.
   if (toolbar_->IsAppMenuFocused()) {
     RestoreFocus();
   } else {
     SaveFocusedView();
+    // TODO(mad): find out how to add this to compact nav view.
     toolbar_->SetPaneFocusAndFocusAppMenu(last_focused_view_storage_id_);
   }
 }
 
 void BrowserView::RotatePaneFocus(bool forwards) {
   // This gets called when the user presses F6 (forwards) or Shift+F6
   // (backwards) to rotate to the next pane. Here, our "panes" are the
   // tab contents and each of our accessible toolbars, infobars, downloads
   // shelf, etc.  When a pane has focus, all of its controls are accessible
   // in the tab traversal, and the tab traversal is "trapped" within that pane.
@@ skipping 79 matching lines @@
 
 bool BrowserView::IsBookmarkBarAnimating() const {
   return bookmark_bar_view_.get() && bookmark_bar_view_->is_animating();
 }
 
 bool BrowserView::IsTabStripEditable() const {
   return tabstrip_->IsTabStripEditable();
 }
 
 bool BrowserView::IsToolbarVisible() const {
-  return browser_->SupportsWindowFeature(Browser::FEATURE_TOOLBAR) ||
-         browser_->SupportsWindowFeature(Browser::FEATURE_LOCATIONBAR);
+  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();
 #endif  // No tricks are needed to get the right behavior on Linux.
 }
 
 void BrowserView::ConfirmSetDefaultSearchProvider(
     TabContents* tab_contents,
@@ skipping 23 matching lines @@
 
 views::Window* BrowserView::DoShowAboutChromeDialog() {
   return browser::ShowAboutChromeView(GetWindow()->GetNativeWindow(),
                                       browser_->profile());
 }
 
 void BrowserView::ShowUpdateChromeDialog() {
   UpdateRecommendedMessageBox::ShowMessageBox(GetWindow()->GetNativeWindow());
 }
 
+void BrowserView::ShowCompactLocationBarUnderSelectedTab() {
+  if (!UseCompactNavigationBar())
+    return;
+  compact_location_bar_view_host_->UpdateOnTabChange(browser()->active_index(),
+                                                     true);
+}
+
 void BrowserView::ShowTaskManager() {
   browser::ShowTaskManager();
 }
 
 void BrowserView::ShowBackgroundPages() {
   browser::ShowBackgroundPages();
 }
 
 void BrowserView::ShowBookmarkBubble(const GURL& url, bool already_bookmarked) {
-  toolbar_->location_bar()->ShowStarBubble(url, !already_bookmarked);
+  GetLocationBarView()->ShowStarBubble(url, !already_bookmarked);
 }
 
 void BrowserView::SetDownloadShelfVisible(bool visible) {
   // This can be called from the superclass destructor, when it destroys our
   // child views. At that point, browser_ is already gone.
   if (browser_ == NULL)
     return;
 
   if (visible && IsDownloadShelfVisible() != visible) {
     // Invoke GetDownloadShelf to force the shelf to be created.
@@ skipping 80 matching lines @@
 void BrowserView::ShowPageInfo(Profile* profile,
                                const GURL& url,
                                const NavigationEntry::SSLStatus& ssl,
                                bool show_history) {
   gfx::NativeWindow parent = GetWindow()->GetNativeWindow();
 
   browser::ShowPageInfoBubble(parent, profile, url, ssl, show_history);
 }
 
 void BrowserView::ShowAppMenu() {
+  // TODO(mad): find out how to add this to compact nav view.
   toolbar_->app_menu()->Activate();
 }
 
 bool BrowserView::PreHandleKeyboardEvent(const NativeWebKeyboardEvent& event,
                                          bool* is_keyboard_shortcut) {
   if (event.type != WebKit::WebInputEvent::RawKeyDown)
     return false;
 
 #if defined(OS_WIN)
   // As Alt+F4 is the close-app keyboard shortcut, it needs processing
@@ skipping 75 matching lines @@
 void BrowserView::HandleKeyboardEvent(const NativeWebKeyboardEvent& event) {
   // TODO(ben): figure out why are these two code paths so different
 #if defined(TOOLKIT_USES_GTK) && !defined(TOUCH_UI)
   HandleWebKeyboardEvent(GetWidget(), event);
 #else
   unhandled_keyboard_event_handler_.HandleKeyboardEvent(event,
                                                         GetFocusManager());
 #endif
 }
 
+void BrowserView::ToggleUseCompactNavigationBar() {
+  bool use_compact_navigation_bar = UseCompactNavigationBar();
+  // Compact Navigation Bar only works with horizontal tabs for now!
+  if (use_compact_navigation_bar && UseVerticalTabs())
+    browser()->ExecuteCommand(IDC_TOGGLE_VERTICAL_TABS);
+  compact_location_bar_view_host_->SetEnabled(use_compact_navigation_bar);
+  compact_location_bar_view_host_->Hide(!use_compact_navigation_bar);
+  Layout();
+}
+
 // TODO(devint): http://b/issue?id=1117225 Cut, Copy, and Paste are always
 // enabled in the page menu regardless of whether the command will do
 // anything. When someone selects the menu item, we just act as if they hit
 // the keyboard shortcut for the command by sending the associated key press
 // to windows. The real fix to this bug is to disable the commands when they
 // won't do anything. We'll need something like an overall clipboard command
 // manager to do that.
 void BrowserView::Cut() {
   ui_controls::SendKeyPress(GetNativeHandle(), ui::VKEY_X,
                             true, false, false, false);
 }
 
 void BrowserView::Copy() {
   ui_controls::SendKeyPress(GetNativeHandle(), ui::VKEY_C,
                             true, false, false, false);
 }
 
 void BrowserView::Paste() {
   ui_controls::SendKeyPress(GetNativeHandle(), ui::VKEY_V,
                             true, false, false, false);
 }
 
 void BrowserView::ToggleTabStripMode() {
+  // Compact Navigation Bar only works with horizontal tabs for now!
+  if (UseVerticalTabs() && UseCompactNavigationBar())
+    browser()->ExecuteCommand(IDC_COMPACT_NAVBAR);
+
   InitTabStrip(browser_->tabstrip_model());
   frame_->TabStripDisplayModeChanged();
 }
 
 void BrowserView::PrepareForInstant() {
   contents_->FadeActiveContents();
 }
 
 void BrowserView::ShowInstant(TabContentsWrapper* preview) {
   if (!preview_container_)
@@ skipping 43 matching lines @@
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserView, BrowserWindowTesting implementation:
 
 BookmarkBarView* BrowserView::GetBookmarkBarView() const {
   return bookmark_bar_view_.get();
 }
 
 LocationBarView* BrowserView::GetLocationBarView() const {
-  return toolbar_->location_bar();
+  if (UseCompactNavigationBar()) {
+    return compact_location_bar_view_host_->GetCompactLocationBarView()->
+        location_bar_view();
+  } else {
+    return toolbar_ ? toolbar_->location_bar() : NULL;
+  }
 }
 
 views::View* BrowserView::GetTabContentsContainerView() const {
   return contents_container_->GetFocusView();
 }
 
 views::View* BrowserView::GetSidebarContainerView() const {
   if (!sidebar_container_)
     return NULL;
   return sidebar_container_->GetFocusView();
@@ skipping 300 matching lines @@
   // Comment out for one cycle to see if this fixes dist tests.
   // tabstrip_->DestroyDragController();
 
   status_bubble_->Reposition();
 
   BrowserBubbleHost::WindowMoved();
 
   browser::HideBookmarkBubbleView();
 
   // Close the omnibox popup, if any.
-  if (toolbar_ && toolbar_->location_bar())
-    toolbar_->location_bar()->location_entry()->ClosePopup();
+  LocationBarView* location_bar_view = GetLocationBarView();
+  if (location_bar_view)
+    location_bar_view->location_entry()->ClosePopup();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserView, views::ClientView overrides:
 
 bool BrowserView::CanClose() {
   // You cannot close a frame for which there is an active originating drag
   // session.
     if (tabstrip_ && !tabstrip_->IsTabStripCloseable())
       return false;
@@ skipping 258 matching lines @@
     jumplist_.reset(new JumpList);
     jumplist_->AddObserver(browser_->profile());
   }
 
   if (AeroPeekManager::Enabled()) {
     aeropeek_manager_.reset(new AeroPeekManager(
         frame_->GetWindow()->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);
+    compact_navigation_bar_->SetID(VIEW_ID_COMPACT_NAV_BAR);
+    AddChildView(compact_navigation_bar_);
+    compact_navigation_bar_->Init();
+    compact_options_bar_ = new CompactOptionsBar(this);
+    compact_options_bar_->SetID(VIEW_ID_COMPACT_OPT_BAR);
+    AddChildView(compact_options_bar_);
+    compact_options_bar_->Init();
+  }
+
+  // Use an empty view for the spacer since all it does is that it replaces the
+  // toolbar area in compact navigation mode.
+  compact_spacer_ = new views::View();
+  compact_spacer_->SetID(VIEW_ID_COMPACT_NAV_BAR_SPACER);
+  AddChildView(compact_spacer_);
 
   // We're now initialized and ready to process Layout requests.
   ignore_layout_ = false;
 }
 
 void BrowserView::LoadingAnimationCallback() {
   base::TimeTicks now = base::TimeTicks::Now();
   if (!last_animation_time_.is_null()) {
     UMA_HISTOGRAM_TIMES(
         "Tabs.LoadingAnimationTime",
@@ skipping 248 matching lines @@
   *old_view = new_view;
   return changed;
 }
 
 void BrowserView::ProcessFullscreen(bool fullscreen) {
   // Reduce jankiness during the following position changes by:
   //   * Hiding the window until it's in the final position
   //   * Ignoring all intervening Layout() calls, which resize the webpage and
   //     thus are slow and look ugly
   ignore_layout_ = true;
-  LocationBarView* location_bar = toolbar_->location_bar();
+  LocationBarView* location_bar = GetLocationBarView();
 #if defined(OS_WIN)
   OmniboxViewWin* omnibox_view =
       static_cast<OmniboxViewWin*>(location_bar->location_entry());
 #endif
   if (!fullscreen) {
     // Hide the fullscreen bubble as soon as possible, since the mode toggle can
     // take enough time for the user to notice.
     fullscreen_bubble_.reset();
   } else {
     // Move focus out of the location bar if necessary.
@@ skipping 345 matching lines @@
       l10n_util::GetStringUTF16(IDS_PRODUCT_NAME));
 
   return view;
 }
 #endif
 
 // static
 FindBar* BrowserWindow::CreateFindBar(Browser* browser) {
   return browser::CreateFindBar(static_cast<BrowserView*>(browser->window()));
 }