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(OS_LINUX)
 #include <gtk/gtk.h>
 #endif
 
@@ skipping 27 matching lines @@
 #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/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 57 matching lines @@
         profile ? profile : browser->profile(),
         Browser::TYPE_NORMAL, true);
     if (normal_browser && normal_browser->window())
       return normal_browser->window()->GetNativeHandle();
   }
 
   return browser->window()->GetNativeHandle();
 }
 #endif  // defined(OS_CHROMEOS)
 
+namespace {
+// A space we insert between the tabstrip and the content in
+// Compact mode.
+class Spacer : public views::View {
+  SkBitmap* background_;

[Peter Kasting, 2011/05/03 18:04:24]

Nit: Put this in a section.

[SteveT, 2011/05/06 18:48:43]

Spacer class was removed since we eventually ended up just using an empty view
to block out the space.

+ public:
+  explicit Spacer(SkBitmap* bitmap) : background_(bitmap) {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(Spacer);
+};
+
+// TODO(sky): wire this back up.
+/*
+// A chromeos implementation of Tab that shows the compact location bar.
+class ChromeosTab : public Tab {

[Peter Kasting, 2011/05/03 18:04:24]

Nit: Wouldn't ChromeOSTab be better?  (2 classes)

[SteveT, 2011/05/06 18:48:43]

Actually, this commented out code that sky/oshima had originally is no longer
necessary since we're handling this MouseEvent through the Tab[Strip] Controller
classes rather than deriving from Tab/TabStrip again. Removed.

+ public:
+  ChromeosTab(TabStrip* tab_strip, chromeos::BrowserView* browser_view)
+      : Tab(tab_strip),
+        browser_view_(browser_view) {
+  }
+  virtual ~ChromeosTab() {}
+
+  // Overridden from views::View.
+  virtual void OnMouseEntered(const views::MouseEvent& event) {

[Peter Kasting, 2011/05/03 18:04:24]

Nit: Use OVERRIDE (here and elsewhere)

I also suggest just saying "views::View:" instead of "Overridden from xxx".

[SteveT, 2011/05/06 18:48:43]

Deleted, as above.

+    TabRenderer::OnMouseEntered(event);
+    browser_view_->ShowCompactLocationBarUnderSelectedTab();
+  }
+
+ private:
+  chromeos::BrowserView* browser_view_;
+
+  DISALLOW_COPY_AND_ASSIGN(ChromeosTab);
+};
+
+// A Tabstrip that uses ChromeosTab as a Tab implementation.
+class ChromeosTabStrip : public TabStrip {
+ public:
+  ChromeosTabStrip(TabStripModel* model, chromeos::BrowserView* browser_view)
+      : TabStrip(model), browser_view_(browser_view) {
+  }
+  virtual ~ChromeosTabStrip() {}
+
+ protected:
+  // Overridden from TabStrip.
+  virtual Tab* CreateTab() {
+    return new ChromeosTab(this, browser_view_);
+  }
+
+ private:
+  chromeos::BrowserView* browser_view_;
+
+  DISALLOW_COPY_AND_ASSIGN(ChromeosTabStrip);
+};
+*/
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // BookmarkExtensionBackground, private:
 // This object serves as the views::Background object which is used to layout
 // and paint the bookmark bar.
 class BookmarkExtensionBackground : public views::Background {
  public:
   explicit BookmarkExtensionBackground(BrowserView* browser_view,
                                        DetachableToolbarView* host_view,
                                        Browser* browser);
 
@@ skipping 129 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),
+      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 = 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 252 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_->Update(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_->Update(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(OS_LINUX) && !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 292 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 256 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
+  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();
+
+  ThemeProvider* theme_provider = frame()->GetThemeProviderForFrame();
+  SkBitmap* theme_toolbar = theme_provider->GetBitmapNamed(IDR_THEME_TOOLBAR);
+  spacer_ = new Spacer(theme_toolbar);
+  spacer_->SetID(VIEW_ID_SPACER);
+  AddChildView(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()));
 }