Implement sidebar support for extension action popups

chrome/browser/ui/views/frame/browser_view.cc

 // Copyright 2012 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"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/i18n/rtl.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/app_mode/app_mode_utils.h"
 #include "chrome/browser/bookmarks/bookmark_stats.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_util.h"
+#include "chrome/browser/extensions/sidebar_container.h"
+#include "chrome/browser/extensions/sidebar_manager.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/native_window_notification_source.h"
 #include "chrome/browser/profiles/avatar_menu.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_avatar_icon_util.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profile_window.h"
 #include "chrome/browser/profiles/profiles_state.h"
@@ skipping 90 matching lines @@
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/theme_provider.h"
 #include "ui/content_accelerators/accelerator_util.h"
 #include "ui/events/event_utils.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/screen.h"
 #include "ui/strings/grit/ui_strings.h"
 #include "ui/views/controls/button/menu_button.h"
+#include "ui/views/controls/single_split_view.h"
+#include "ui/views/controls/single_split_view_listener.h"
 #include "ui/views/controls/textfield/textfield.h"
 #include "ui/views/controls/webview/webview.h"
 #include "ui/views/focus/external_focus_tracker.h"
 #include "ui/views/focus/view_storage.h"
+#include "ui/views/layout/box_layout.h"
 #include "ui/views/layout/grid_layout.h"
 #include "ui/views/widget/native_widget.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/window/dialog_delegate.h"
 
 #if defined(USE_AURA)
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
@@ skipping 364 matching lines @@
 
   // Explicitly set browser_ to null.
   browser_.reset();
 }
 
 void BrowserView::Init(Browser* browser) {
   browser_.reset(browser);
   browser_->tab_strip_model()->AddObserver(this);
   immersive_mode_controller_.reset(
       chrome::CreateImmersiveModeController(browser_->host_desktop_type()));
+
+  extensions::SidebarManager* sidebar_manager =
+      extensions::SidebarManager::GetFromContext(browser_->profile());
+  sidebar_manager->AddObserver(this);
 }
 
 // static
 BrowserView* BrowserView::GetBrowserViewForNativeWindow(
     gfx::NativeWindow window) {
   views::Widget* widget = views::Widget::GetWidgetForNativeWindow(window);
   return widget ?
       reinterpret_cast<BrowserView*>(widget->GetNativeWindowProperty(
           kBrowserViewKey)) : nullptr;
 }
 
 // static
 BrowserView* BrowserView::GetBrowserViewForBrowser(const Browser* browser) {
   return static_cast<BrowserView*>(browser->window());
 }
 
 void BrowserView::InitStatusBubble() {
   status_bubble_.reset(new StatusBubbleViews(contents_web_view_));
   contents_web_view_->SetStatusBubble(status_bubble_.get());
 }
 
+bool BrowserView::SplitHandleMoved(views::SingleSplitView* sender) {
+  for (int i = 0; i < sender->child_count(); ++i)
+    sender->child_at(i)->InvalidateLayout();
+  SchedulePaint();
+  Layout();
+  return false;
+}
+
 gfx::Rect BrowserView::GetToolbarBounds() const {
   gfx::Rect toolbar_bounds(toolbar_->bounds());
   if (toolbar_bounds.IsEmpty())
     return toolbar_bounds;
   // The apparent toolbar edges are outside the "real" toolbar edges.
   toolbar_bounds.Inset(-views::NonClientFrameView::kClientEdgeThickness, 0);
   return toolbar_bounds;
 }
 
 gfx::Rect BrowserView::GetFindBarBoundingBox() const {
@@ skipping 94 matching lines @@
 }
 
 WebContents* BrowserView::GetActiveWebContents() const {
   return browser_->tab_strip_model()->GetActiveWebContents();
 }
 
 gfx::ImageSkia BrowserView::GetOTRAvatarIcon() const {
   return *GetThemeProvider()->GetImageSkiaNamed(IDR_OTR_ICON);
 }
 
+void BrowserView::OnSidebarShown(content::WebContents* tab,
+                                 const std::string& content_id) {
+  UpdateSidebarForContents(tab);
+}
+
+void BrowserView::OnSidebarHidden(content::WebContents* tab,
+                                  const std::string& content_id) {
+  UpdateSidebarForContents(tab);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserView, BrowserWindow implementation:
 
 void BrowserView::Show() {
 #if !defined(OS_WIN)
   // The Browser associated with this browser window must become the active
   // browser at the time |Show()| is called. This is the natural behavior under
   // Windows and Ash, but other platforms will not trigger
   // OnWidgetActivationChanged() until we return to the runloop. Therefore any
   // calls to Browser::GetLastActive() will return the wrong result if we do not
@@ skipping 209 matching lines @@
     PermissionBubbleManager::FromWebContents(new_contents)->SetView(
         permission_bubble_.get());
   }
 
   UpdateUIForContents(new_contents);
 
   // Layout for DevTools _before_ setting the both main and devtools WebContents
   // to avoid toggling the size of any of them.
   UpdateDevToolsForContents(new_contents, !change_tab_contents);
 
+  UpdateSidebarForContents(new_contents);
   if (change_tab_contents) {
     web_contents_close_handler_->ActiveTabChanged();
     contents_web_view_->SetWebContents(new_contents);
     // The second layout update should be no-op. It will just set the
     // DevTools WebContents.
     UpdateDevToolsForContents(new_contents, true);
   }
 
   if (!browser_->tab_strip_model()->closing_all() && GetWidget()->IsActive() &&
       GetWidget()->IsVisible()) {
@@ skipping 408 matching lines @@
     anchor_view = toolbar_->app_menu();
   else
     anchor_view = toolbar_->location_bar();
 
   OneClickSigninBubbleView::ShowBubble(type, email, error_message,
                                        delegate.Pass(), anchor_view,
                                        start_sync_callback);
 }
 #endif
 
+int BrowserView::GetSidebarWidth() const {
+  if (!sidebar_container_ || !sidebar_container_->visible())
+    return 0;
+  return sidebar_split_->divider_offset();
+}
+
 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_)
     return;
 
   if (visible && IsDownloadShelfVisible() != visible) {
     // Invoke GetDownloadShelf to force the shelf to be created.
     GetDownloadShelf();
   }
@@ skipping 233 matching lines @@
   // browser_->GetActiveWebContents() will return null or something else.
   if (index == browser_->tab_strip_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 WebContents when it is removed.
     web_contents_close_handler_->ActiveTabChanged();
     contents_web_view_->SetWebContents(nullptr);
     infobar_container_->ChangeInfoBarManager(nullptr);
     UpdateDevToolsForContents(nullptr, true);
   }
+  UpdateSidebarForContents(NULL);
 }
 
 void BrowserView::TabDeactivated(WebContents* contents) {
   if (PermissionBubbleManager::FromWebContents(contents))
     PermissionBubbleManager::FromWebContents(contents)->SetView(nullptr);
 
   // 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->IsBeingDestroyed())
@@ skipping 458 matching lines @@
   devtools_web_view_->SetVisible(false);
 
   contents_container_ = new views::View();
   contents_container_->set_background(views::Background::CreateSolidBackground(
       ThemeProperties::GetDefaultColor(
           ThemeProperties::COLOR_CONTROL_BACKGROUND)));
   contents_container_->AddChildView(devtools_web_view_);
   contents_container_->AddChildView(contents_web_view_);
   contents_container_->SetLayoutManager(new ContentsLayoutManager(
       devtools_web_view_, contents_web_view_));
-  AddChildView(contents_container_);
-  set_contents_view(contents_container_);
+
+  sidebar_web_view_ = new views::WebView(browser_->profile());
+  sidebar_web_view_->set_id(VIEW_ID_SIDE_BAR_VIEW);
+  sidebar_web_view_->SetVisible(false);
+
+  sidebar_container_ = new views::View();
+  sidebar_container_->AddChildView(sidebar_web_view_);
+  sidebar_container_->set_id(VIEW_ID_SIDE_BAR_CONTAINER);
+  sidebar_container_->SetVisible(false);
+
+  sidebar_split_ = new views::SingleSplitView(
+      contents_container_, sidebar_container_,
+      views::SingleSplitView::HORIZONTAL_SPLIT, this);
+
+  sidebar_split_->set_id(VIEW_ID_SIDE_BAR_SPLIT);
+  sidebar_split_->set_background(views::Background::CreateSolidBackground(
+      GetWidget()->GetThemeProvider()->GetColor(
+          ThemeProperties::COLOR_TOOLBAR)));
+  sidebar_split_->set_resize_leading_on_bounds_change(false);
+  AddChildView(sidebar_split_);
+  set_contents_view(sidebar_split_);
 
   // Top container holds tab strip and toolbar and lives at the front of the
   // view hierarchy.
   top_container_ = new TopContainerView(this);
   AddChildView(top_container_);
 
   // TabStrip takes ownership of the controller.
   BrowserTabStripController* tabstrip_controller =
       new BrowserTabStripController(browser_.get(),
                                     browser_->tab_strip_model());
   tabstrip_ = new TabStrip(tabstrip_controller);
   top_container_->AddChildView(tabstrip_);
   tabstrip_controller->InitFromModel(tabstrip_);
 
   toolbar_ = new ToolbarView(browser_.get());
   top_container_->AddChildView(toolbar_);
   toolbar_->Init();
 
   InitStatusBubble();
 
   // Create do-nothing view for the sake of controlling the z-order of the find
   // bar widget.
   find_bar_host_view_ = new View();
   AddChildView(find_bar_host_view_);
 
   immersive_mode_controller_->Init(this);
 
   BrowserViewLayout* browser_view_layout = new BrowserViewLayout;
-  browser_view_layout->Init(new BrowserViewLayoutDelegateImpl(this),
-                            browser(),
-                            this,
-                            top_container_,
-                            tabstrip_,
-                            toolbar_,
-                            infobar_container_,
-                            contents_container_,
-                            GetContentsLayoutManager(),
-                            immersive_mode_controller_.get());
+  browser_view_layout->Init(
+      new BrowserViewLayoutDelegateImpl(this), browser(), this, top_container_,
+      tabstrip_, toolbar_, infobar_container_, sidebar_split_,
+      GetContentsLayoutManager(), immersive_mode_controller_.get());
   SetLayoutManager(browser_view_layout);
 
 #if defined(OS_WIN)
   // Create a custom JumpList and add it to an observer of TabRestoreService
   // so we can update the custom JumpList when a tab is added or removed.
   if (JumpList::Enabled()) {
     load_complete_listener_.reset(new LoadCompleteListener(this));
   }
 #endif
 
   GetLocationBar()->GetOmniboxView()->model()->popup_model()->AddObserver(this);
 }
 
+void BrowserView::UpdateSidebarForContents(content::WebContents* new_contents) {
+  if (!sidebar_container_)
+    return;  // Happens when sidebar is not allowed.
+  extensions::SidebarManager* sidebar_manager =
+      extensions::SidebarManager::GetFromContext(browser_->profile());
+  if (!sidebar_manager)
+    return;  // Happens only in tests.s
+
+  WebContents* sidebar_contents = NULL;
+  if (new_contents) {
+    SidebarContainer* client_host =
+        sidebar_manager->GetActiveSidebarContainerFor(new_contents);
+    if (client_host)
+      sidebar_contents = client_host->host_contents();
+  }
+
+  bool visible = NULL != sidebar_contents;
+
+  bool should_show = visible && !sidebar_container_->visible();
+  bool should_hide = !visible && sidebar_container_->visible();
+
+  // Update sidebar content.
+  WebContents* old_contents =
+      static_cast<WebContents*>(sidebar_web_view_->web_contents());
+
+  sidebar_web_view_->SetWebContents(sidebar_contents);
+
+  sidebar_manager->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) {
+      // By default sidebar width is 1/7th of the current page content width.
+      sidebar_width = sidebar_split_->width() / 7;
+    }
+    int min_sidebar_width = sidebar_split_->GetMinimumSize().width();
+    // Not allowed to be wider than 50% of the split-view's frame
+    sidebar_width = std::min(sidebar_split_->width() / 2 - 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_web_view_->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::LoadingAnimationCallback() {
   base::TimeTicks now = base::TimeTicks::Now();
   if (!last_animation_time_.is_null()) {
     UMA_HISTOGRAM_TIMES(
         "Tabs.LoadingAnimationTime",
         now - last_animation_time_);
   }
   last_animation_time_ = now;
   if (browser_->is_type_tabbed()) {
     // Loading animations are shown in the tab for tabbed windows.  We check the
@@ skipping 507 matching lines @@
   return immersive_mode_controller()->IsEnabled();
 }
 
 views::Widget* BrowserView::GetBubbleAssociatedWidget() {
   return GetWidget();
 }
 
 gfx::Rect BrowserView::GetTopContainerBoundsInScreen() {
   return top_container_->GetBoundsInScreen();
 }