Rip Out the Sidebar API

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 18 matching lines @@
 #include "chrome/browser/instant/instant_controller.h"
 #include "chrome/browser/native_window_notification_source.h"
 #include "chrome/browser/ntp_background_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/avatar_menu_model.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sessions/tab_restore_service.h"
 #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/dialog_style.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"
@@ skipping 264 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),
       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),
 #if defined(OS_WIN) && !defined(USE_AURA)
       hung_window_detector_(&hung_plugin_action_),
       ticker_(0),
 #endif
       force_location_bar_focus_(false) {
   browser_->tabstrip_model()->AddObserver(this);
-
-  registrar_.Add(
-      this,
-      chrome::NOTIFICATION_SIDEBAR_CHANGED,
-      content::Source<SidebarManager>(SidebarManager::GetInstance()));
 }
 
 BrowserView::~BrowserView() {
 #if defined(USE_AURA)
   // Destroy LauncherIconUpdater early on as it listens to the TabstripModel,
   // which is destroyed by the browser.
   icon_updater_.reset();
 #endif
 
   browser_->tabstrip_model()->RemoveObserver(this);
@@ skipping 83 matching lines @@
 gfx::Point BrowserView::OffsetPointForToolbarBackgroundImage(
     const gfx::Point& point) const {
   // The background image starts tiling horizontally at the window left edge and
   // vertically at the top edge of the horizontal tab strip (or where it would
   // be).  We expect our parent's origin to be the window origin.
   gfx::Point window_point(point.Add(GetMirroredPosition()));
   window_point.Offset(0, -frame_->GetHorizontalTabStripVerticalOffset(false));
   return window_point;
 }
 
-int BrowserView::GetSidebarWidth() const {
-  if (!sidebar_container_ || !sidebar_container_->visible())
-    return 0;
-  return sidebar_split_->divider_offset();
-}
-
 bool BrowserView::IsTabStripVisible() const {
   return browser_->SupportsWindowFeature(Browser::FEATURE_TABSTRIP);
 }
 
 bool BrowserView::IsOffTheRecord() const {
   return browser_->profile()->IsOffTheRecord();
 }
 
 bool BrowserView::IsGuestSession() const {
   return browser_->profile()->IsGuestSession();
@@ skipping 489 matching lines @@
   // with NULL to represent the tab contents getting focus. If one of these
   // is currently invisible or has no focusable children it will be
   // automatically skipped.
   std::vector<views::AccessiblePaneView*> accessible_panes;
   GetAccessiblePanes(&accessible_panes);
   int pane_count = static_cast<int>(accessible_panes.size());
 
   std::vector<views::View*> accessible_views(
       accessible_panes.begin(), accessible_panes.end());
   accessible_views.push_back(GetTabContentsContainerView());
-  if (sidebar_container_ && sidebar_container_->visible())
-    accessible_views.push_back(GetSidebarContainerView());
   if (devtools_container_->visible())
     accessible_views.push_back(devtools_container_->GetFocusView());
   int count = static_cast<int>(accessible_views.size());
 
   // Figure out which view (if any) currently has the focus.
   const views::View* focused_view = GetFocusManager()->GetFocusedView();
   int index = -1;
   if (focused_view) {
     for (int i = 0; i < count; ++i) {
       if (accessible_views[i] == focused_view ||
@@ skipping 399 matching lines @@
 }
 
 LocationBarView* BrowserView::GetLocationBarView() const {
   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();
-}
-
 ToolbarView* BrowserView::GetToolbarView() const {
   return toolbar_;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// BrowserView, content::NotificationObserver implementation:
-
-void BrowserView::Observe(int type,
-                          const content::NotificationSource& source,
-                          const content::NotificationDetails& details) {
-  switch (type) {
-    case chrome::NOTIFICATION_SIDEBAR_CHANGED:
-      if (content::Details<SidebarContainer>(details)->tab_contents() ==
-          browser_->GetSelectedTabContents()) {
-        UpdateSidebar();
-      }
-      break;
-
-    default:
-      NOTREACHED() << "Got a notification we didn't register for!";
-      break;
-  }
-}
-
-///////////////////////////////////////////////////////////////////////////////

[Devlin, 2011/12/21 02:11:27]

Am I right in thinking that, since the sidebar was the only notification, we no
longer need to implement the observe method or inherit from
NotificationObserver?

[Aaron Boodman, 2011/12/21 08:38:20]

Yes. Also good job removing registrar_.

 // BrowserView, TabStripModelObserver implementation:
 
 void BrowserView::TabDetachedAt(TabContentsWrapper* 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()->active_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.
     contents_container_->ChangeTabContents(NULL);
     infobar_container_->ChangeTabContents(NULL);
-    UpdateSidebarForContents(NULL);
     UpdateDevToolsForContents(NULL);
   }
 }
 
 void BrowserView::TabDeactivated(TabContentsWrapper* contents) {
   // 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->tab_contents()->is_being_destroyed())
     contents->tab_contents()->view()->StoreFocus();
@@ skipping 480 matching lines @@
 
   infobar_container_ = new InfoBarContainerView(this);
   AddChildView(infobar_container_);
 
   contents_container_ = new TabContentsContainer;
   contents_ = new ContentsContainer(contents_container_);
 
   SkColor bg_color = GetWidget()->GetThemeProvider()->
       GetColor(ThemeService::COLOR_TOOLBAR);
 
-  bool sidebar_allowed = SidebarManager::IsSidebarAllowed();
-  if (sidebar_allowed) {
-    sidebar_container_ = new TabContentsContainer;
-    sidebar_container_->set_id(VIEW_ID_SIDE_BAR_CONTAINER);
-    sidebar_container_->SetVisible(false);
-
-    sidebar_split_ = new views::SingleSplitView(
-        contents_,
-        sidebar_container_,
-        views::SingleSplitView::HORIZONTAL_SPLIT,
-        this);
-    sidebar_split_->set_id(VIEW_ID_SIDE_BAR_SPLIT);
-    sidebar_split_->SetAccessibleName(
-        l10n_util::GetStringUTF16(IDS_ACCNAME_SIDE_BAR));
-    sidebar_split_->set_background(
-        views::Background::CreateSolidBackground(bg_color));
-  }
-
   devtools_container_ = new TabContentsContainer;
   devtools_container_->set_id(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);
   contents_split_->set_id(VIEW_ID_CONTENTS_SPLIT);
   contents_split_->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_ACCNAME_WEB_CONTENTS));
   contents_split_->set_background(
@@ skipping 120 matching lines @@
   return UpdateChildViewAndLayout(new_bookmark_bar_view, &active_bookmark_bar_);
 }
 
 bool BrowserView::MaybeShowInfoBar(TabContentsWrapper* contents) {
   // TODO(beng): Remove this function once the interface between
   //             InfoBarContainer, DownloadShelfView and TabContents and this
   //             view is sorted out.
   return true;
 }
 
-void BrowserView::UpdateSidebar() {
-  UpdateSidebarForContents(GetSelectedTabContentsWrapper());
-  Layout();
-}
-
-void BrowserView::UpdateSidebarForContents(TabContentsWrapper* tab_contents) {
-  if (!sidebar_container_)
-    return;  // Happens when sidebar is not allowed.
-  if (!SidebarManager::GetInstance())
-    return;  // Happens only in tests.
-
-  TabContents* sidebar_contents = NULL;
-  if (tab_contents) {
-    SidebarContainer* client_host = SidebarManager::GetInstance()->
-        GetActiveSidebarContainerFor(tab_contents->tab_contents());
-    if (client_host)
-      sidebar_contents = client_host->sidebar_contents();
-  }
-
-  bool visible = NULL != sidebar_contents &&
-                 browser_->SupportsWindowFeature(Browser::FEATURE_SIDEBAR);
-
-  bool should_show = visible && !sidebar_container_->visible();
-  bool should_hide = !visible && sidebar_container_->visible();
-
-  // Update sidebar content.
-  TabContents* old_contents = sidebar_container_->tab_contents();
-  sidebar_container_->ChangeTabContents(sidebar_contents);
-  SidebarManager::GetInstance()->
-      NotifyStateChanges(old_contents, sidebar_contents);
-
-  // Update sidebar UI width.
-  if (should_show) {
-    // Restore split offset.
-    int sidebar_width = g_browser_process->local_state()->GetInteger(
-        prefs::kExtensionSidebarWidth);
-    if (sidebar_width < 0) {
-      // Initial load, set to default value.
-      sidebar_width = sidebar_split_->width() / 7;
-    }
-    // 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();
-  } 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();
-  }
-}
-
 void BrowserView::UpdateDevToolsForContents(TabContentsWrapper* wrapper) {
   TabContents* devtools_contents = NULL;
   if (wrapper) {
     TabContentsWrapper* devtools_contents_wrapper =
         DevToolsWindow::GetDevToolsContents(wrapper->tab_contents());
     if (devtools_contents_wrapper)
       devtools_contents = devtools_contents_wrapper->tab_contents();
   }
 
   bool should_show = devtools_contents && !devtools_container_->visible();
@@ skipping 420 matching lines @@
     contents_container_->ChangeTabContents(NULL);
   infobar_container_->ChangeTabContents(new_contents->infobar_tab_helper());
   if (bookmark_bar_view_.get()) {
     bookmark_bar_view_->SetBookmarkBarState(
         browser_->bookmark_bar_state(),
         BookmarkBar::DONT_ANIMATE_STATE_CHANGE);
   }
   UpdateUIForContents(new_contents);
   if (change_tab_contents)
     contents_container_->ChangeTabContents(new_contents->tab_contents());
-  UpdateSidebarForContents(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->tab_contents()->DidBecomeSelected();
   if (BrowserList::GetLastActive() == browser_ &&
       !browser_->tabstrip_model()->closing_all() && GetWidget()->IsVisible()) {
     // We only restore focus if our window is visible, to avoid invoking blur
@@ skipping 47 matching lines @@
   browser::CreateViewsBubble(bubble);
   bubble->SetAlignment(views::BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
   bubble->Show();
 }
 
 void BrowserView::ShowAvatarBubbleFromAvatarButton() {
   AvatarMenuButton* button = frame_->GetAvatarMenuButton();
   if (button)
     button->ShowAvatarBubble();
 }