Support loading extensions into the bookmark toolbar.

chrome/browser/views/bookmark_bar_view.cc

 // Copyright (c) 2006-2008 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/bookmark_bar_view.h"
 
 #include <limits>
 
 #include "base/string_util.h"
 #include "base/base_drag_source.h"
 #include "chrome/browser/bookmarks/bookmark_context_menu.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/browser_window.h"
 #include "chrome/browser/drag_utils.h"
 #include "chrome/browser/download/download_util.h"
+#include "chrome/browser/extensions/extension.h"
+#include "chrome/browser/extensions/extension_view.h"
+#include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/page_navigator.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/view_ids.h"
 #include "chrome/browser/views/bookmark_editor_view.h"
 #include "chrome/browser/views/event_utils.h"
 #include "chrome/browser/views/frame/browser_view.h"
 #include "chrome/browser/views/input_window.h"
@@ skipping 279 matching lines @@
     BookmarkButton::PaintAnimation(this, canvas,
                                    show_animation_->GetCurrentValue());
   }
 
  private:
   scoped_ptr<SlideAnimation> show_animation_;
 
   DISALLOW_COPY_AND_ASSIGN(BookmarkFolderButton);
 };
 
+// ExtensionToolstrip -------------------------------------------------------
+
+// A simple container with a border for an ExtensionView.
+class ExtensionToolstrip : public views::View {
+ public:
+  static const int kPadding = 2;
+
+  ExtensionToolstrip(const GURL& url, Profile* profile)
+      : view_(new ExtensionView(url, profile)) {
+    AddChildView(view_);
+    set_border(views::Border::CreateEmptyBorder(
+        kPadding, kPadding, kPadding, kPadding));
+  }
+
+  virtual gfx::Size GetPreferredSize() {
+    gfx::Size size = view_->GetPreferredSize();
+    size.Enlarge(kPadding*2, kPadding*2);
+    return size;
+  }
+
+  virtual void DidChangeBounds(const gfx::Rect& previous,
+                               const gfx::Rect& current) {
+    view_->SetBounds(GetLocalBounds(false));
+  }
+
+ private:
+  ExtensionView* view_;
+
+  DISALLOW_COPY_AND_ASSIGN(ExtensionToolstrip);
+};
+
 // DropInfo -------------------------------------------------------------------
 
 // Tracks drops on the BookmarkBarView.
 
 struct DropInfo {
   DropInfo() : drop_index(-1), is_menu_showing(false), valid(false) {}
 
   // Whether the data is valid.
   bool valid;
 
@@ skipping 354 matching lines @@
     : profile_(NULL),
       browser_(browser),
       page_navigator_(NULL),
       model_(NULL),
       other_bookmarked_button_(NULL),
       model_changed_listener_(NULL),
       show_folder_drop_menu_task_(NULL),
       overflow_button_(NULL),
       instructions_(NULL),
       bookmarks_separator_view_(NULL),
-      throbbing_view_(NULL) {
+      throbbing_view_(NULL),
+      num_extension_toolstrips_(0) {
   SetID(VIEW_ID_BOOKMARK_BAR);
   Init();
   SetProfile(profile);
 
 
   if (IsAlwaysShown()) {
     size_animation_->Reset(1);
   } else {
     size_animation_->Reset(0);
   }
@@ skipping 10 matching lines @@
 void BookmarkBarView::SetProfile(Profile* profile) {
   DCHECK(profile);
   if (profile_ == profile)
     return;
 
   StopThrobbing(true);
 
   // Cancels the current cancelable.
   NotifyModelChanged();
 
-  // Remove the current buttons.
-  for (int i = GetBookmarkButtonCount() - 1; i >= 0; --i) {
+  // Remove the current buttons and extension toolstrips.
+  for (int i = GetBookmarkButtonCount() + num_extension_toolstrips_ - 1;
+       i >= 0; --i) {
     View* child = GetChildViewAt(i);
     RemoveChildView(child);
     delete child;
   }
 
   profile_ = profile;
 
   if (model_)
     model_->RemoveObserver(this);
 
   // Disable the other bookmarked button, we'll re-enable when the model is
   // loaded.
   other_bookmarked_button_->SetEnabled(false);
 
   NotificationService* ns = NotificationService::current();
   Source<Profile> ns_source(profile_->GetOriginalProfile());
   ns->AddObserver(this, NotificationType::BOOKMARK_BUBBLE_SHOWN, ns_source);
   ns->AddObserver(this, NotificationType::BOOKMARK_BUBBLE_HIDDEN, ns_source);
   ns->AddObserver(this, NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED,
                   NotificationService::AllSources());
+  ns->AddObserver(this, NotificationType::EXTENSIONS_LOADED,
+                  NotificationService::AllSources());
 
   model_ = profile_->GetBookmarkModel();
   model_->AddObserver(this);
   if (model_->IsLoaded())
     Loaded(model_);
   // else case: we'll receive notification back from the BookmarkModel when done
   // loading, then we'll populate the bar.
 }
 
 void BookmarkBarView::SetPageNavigator(PageNavigator* navigator) {
@@ skipping 73 matching lines @@
     for (int i = 0; i < GetBookmarkButtonCount(); ++i) {
       views::View* child = GetChildViewAt(i);
       gfx::Size pref = child->GetPreferredSize();
       int next_x = x + pref.width() + kButtonPadding;
       child->SetVisible(next_x < max_x);
       child->SetBounds(x, y, pref.width(), height);
       x = next_x;
     }
   }
 
+  // Extension toolstrips.
+  for (int i = GetBookmarkButtonCount();
+       i < GetBookmarkButtonCount() + num_extension_toolstrips_; ++i) {
+    views::View* child = GetChildViewAt(i);
+    gfx::Size pref = child->GetPreferredSize();
+    int next_x = x + pref.width() + kButtonPadding;
+    child->SetVisible(next_x < max_x);
+    child->SetBounds(x, y, pref.width(), height);
+    x = next_x;
+  }
+
   // Layout the right side of the bar.
   const bool all_visible =
       (GetBookmarkButtonCount() == 0 ||
        GetChildViewAt(GetBookmarkButtonCount() - 1)->IsVisible());
 
   // Layout the right side buttons.
   x = max_x + kButtonPadding;
 
   // The overflow button.
   overflow_button_->SetBounds(x, y, overflow_pref.width(), height);
@@ skipping 363 matching lines @@
   // text and flipping the ChromeCanvas object will break text rendering. Since
   // the overflow button does not contain text, we can safely flip it.
   button->EnableCanvasFlippingForRTLUI(true);
 
   // Make visible as necessary.
   button->SetVisible(false);
   return button;
 }
 
 int BookmarkBarView::GetBookmarkButtonCount() {
-  // We contain four non-bookmark button views: recently bookmarked,
-  // bookmarks separator, chevrons (for overflow) and the instruction
-  // label.
-  return GetChildViewCount() - 4;
+  // We contain at least four non-bookmark button views: recently bookmarked,
+  // bookmarks separator, chevrons (for overflow), the instruction
+  // label, as well as any ExtensionViews displaying toolstrips.
+  return GetChildViewCount() - 4 - num_extension_toolstrips_;
 }
 
 void BookmarkBarView::Loaded(BookmarkModel* model) {
   BookmarkNode* node = model_->GetBookmarkBarNode();
   DCHECK(node && model_->other_node());
   // Create a button for each of the children on the bookmark bar.
   for (int i = 0; i < node->GetChildCount(); ++i)
     AddChildView(i, CreateBookmarkButton(node->GetChild(i)));
   other_bookmarked_button_->SetEnabled(true);
+
+  AddExtensionToolstrips(profile_->GetExtensionsService()->extensions());
+
   Layout();
   SchedulePaint();
 }
 
 void BookmarkBarView::BookmarkModelBeingDeleted(BookmarkModel* model) {
   // The bookmark model should never be deleted before us. This code exists
   // to check for regressions in shutdown code and not crash.
   NOTREACHED();
 
   // Do minimal cleanup, presumably we'll be deleted shortly.
@@ skipping 331 matching lines @@
     case NotificationType::BOOKMARK_BUBBLE_SHOWN:
       StopThrobbing(true);
       bubble_url_ = *(Details<GURL>(details).ptr());
       StartThrobbing();
       break;
 
     case NotificationType::BOOKMARK_BUBBLE_HIDDEN:
       StopThrobbing(false);
       bubble_url_ = GURL();
       break;
+
+    case NotificationType::EXTENSIONS_LOADED: {
+      const ExtensionList* extensions = Details<ExtensionList>(details).ptr();
+      if (AddExtensionToolstrips(extensions)) {
+        Layout();
+        SchedulePaint();
+      }
+      break;
+    }
   }
 }
 
+bool BookmarkBarView::AddExtensionToolstrips(const ExtensionList* extensions) {
+  bool added_toolstrip = false;
+  for (ExtensionList::const_iterator extension = extensions->begin();
+       extension != extensions->end(); ++extension) {
+    if (!(*extension)->toolstrip_url().is_empty()) {
+      ExtensionToolstrip* view =
+          new ExtensionToolstrip((*extension)->toolstrip_url(), profile_);
+      int index = GetBookmarkButtonCount() + num_extension_toolstrips_;
+      AddChildView(index, view);
+      added_toolstrip = true;
+      ++num_extension_toolstrips_;
+    }
+  }
+
+  return added_toolstrip;
+}
+
 void BookmarkBarView::RemoveNotificationObservers() {
   NotificationService* ns = NotificationService::current();
   Source<Profile> ns_source(profile_->GetOriginalProfile());
   ns->RemoveObserver(this, NotificationType::BOOKMARK_BUBBLE_SHOWN, ns_source);
   ns->RemoveObserver(this, NotificationType::BOOKMARK_BUBBLE_HIDDEN, ns_source);
   ns->RemoveObserver(this,
                      NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED,
                      NotificationService::AllSources());
+  ns->RemoveObserver(this, NotificationType::EXTENSIONS_LOADED,
+                     NotificationService::AllSources());
 }
 
 void BookmarkBarView::NotifyModelChanged() {
   if (model_changed_listener_)
     model_changed_listener_->ModelChanged();
 }
 
 void BookmarkBarView::ShowDropFolderForNode(BookmarkNode* node) {
   if (drop_menu_runner_.get() && drop_menu_runner_->GetNode() == node) {
     // Already showing for the specified node.
@@ skipping 279 matching lines @@
 }
 
 void BookmarkBarView::StopThrobbing(bool immediate) {
   if (!throbbing_view_)
     return;
 
   // If not immediate, cycle through 2 more complete cycles.
   throbbing_view_->StartThrobbing(immediate ? 0 : 4);
   throbbing_view_ = NULL;
 }