add mole info to toolstrip definition and enable moles

chrome/browser/views/extensions/extension_shelf.cc

 // Copyright (c) 2009 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/extensions/extension_shelf.h"
 
 #include <algorithm>
 
 #include "app/resource_bundle.h"
 #include "base/logging.h"
@@ skipping 68 matching lines @@
 private:
   DISALLOW_COPY_AND_ASSIGN(PlaceholderView);
 };
 
 // A wrapper class for the ExtensionHost displayed as a toolstrip.
 // The class itself also acts as the View for the handle of the toolstrip
 // it represents.
 class ExtensionShelf::Toolstrip : public views::View,
                                   public BrowserBubble::Delegate {
  public:
-  Toolstrip(ExtensionShelf* shelf, ExtensionHost* host);
+  Toolstrip(ExtensionShelf* shelf, ExtensionHost* host,
+            Extension::ToolstripInfo* info);
   virtual ~Toolstrip();
 
   // View
   virtual void Paint(gfx::Canvas* canvas);
   virtual gfx::Size GetPreferredSize();
   virtual void Layout();
   virtual void OnMouseEntered(const views::MouseEvent& event);
   virtual void OnMouseExited(const views::MouseEvent& event);
   virtual bool OnMousePressed(const views::MouseEvent& event);
   virtual bool OnMouseDragged(const views::MouseEvent& event);
@@ skipping 39 matching lines @@
 
   // Show / Hide the shelf handle.
   void ShowShelfHandle();
   void DoShowShelfHandle();
   void HideShelfHandle(int delay_ms);
   void DoHideShelfHandle();
   void StopHandleTimer();
 
   // BrowserBubble::Delegate
   virtual void BubbleBrowserWindowMoved(BrowserBubble* bubble);
-  virtual void BubbleBrowserWindowClosed(BrowserBubble* bubble);
+  virtual void BubbleBrowserWindowClosing(BrowserBubble* bubble);
 
  private:
   // The actual renderer that this toolstrip contains.
   ExtensionHost* host_;
 
+  // Manifest definition of this toolstrip.
+  Extension::ToolstripInfo* info_;
+
   // The handle is a BrowserBubble so that it can exist as an independent,
   // floating window.  It also acts as the container for the ExtensionView when
   // it's being dragged.
   scoped_ptr<BrowserBubble> handle_;
 
   // Used for drawing the name of the extension in the handle.
   scoped_ptr<views::Label> title_;
 
   // Pointer back to the containing shelf.
   ExtensionShelf* shelf_;
@@ skipping 12 matching lines @@
   // If dragging, where did the drag start from.
   gfx::Point initial_drag_location_;
 
   // Timers for tracking mouse hovering.
   ScopedRunnableMethodFactory<ExtensionShelf::Toolstrip> timer_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Toolstrip);
 };
 
 ExtensionShelf::Toolstrip::Toolstrip(ExtensionShelf* shelf,
-                                     ExtensionHost* host)
+                                     ExtensionHost* host,
+                                     Extension::ToolstripInfo* info)
     : host_(host),
+      info_(info),
       shelf_(shelf),
       placeholder_view_(NULL),
       dragging_(false),
       expanded_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(timer_factory_(this)) {
   DCHECK(host->view());
   // We're owned by shelf_, not the bubble that we get inserted in and out of.
   SetParentOwned(false);
 
   std::wstring name = UTF8ToWide(host_->extension()->name());
@@ skipping 36 matching lines @@
     // when we're dragging, draw the bottom border.
     canvas->FillRectInt(kBorderColor, 0, height() - 1, width(), 1);
   }
 }
 
 gfx::Size ExtensionShelf::Toolstrip::GetPreferredSize() {
   gfx::Size sz = title_->GetPreferredSize();
   int width = std::max(view()->width() + 2, sz.width());
   sz.set_width(width);
   sz.Enlarge(kHandlePadding * 2, kHandlePadding * 2);
-  if (dragging_) {
+  if (dragging_ || expanded) {
     gfx::Size extension_size = view()->GetPreferredSize();
     sz.Enlarge(0, extension_size.height() + 2);
-  } else if (expanded_) {
-    // TODO(erikkay) these sizes are a temporary hack until we can get the
-    // size from the extension itself.
-    const int tempHeight = 200;
-    const int tempWidth = 400;
-    int width = std::max(sz.width(), tempWidth);
-    sz.set_width(width);
-    gfx::Size extension_size = view()->GetPreferredSize();
-    sz.Enlarge(0, extension_size.height() + 2 + tempHeight);
   }
   return sz;
 }
 
 void ExtensionShelf::Toolstrip::Layout() {
   if (dragging_ || expanded_) {
     int y = title_->bounds().bottom() + kHandlePadding + 1;
     view()->SetBounds(1, y, view()->width(), view()->height());
   }
 }
@@ skipping 41 matching lines @@
 
     // TODO(erikkay) as this gets dragged around, update the placeholder view
     // on the shelf to show where it will get dropped to.
     handle_->MoveTo(screen.x(), screen.y());
   }
   return true;
 }
 
 void ExtensionShelf::Toolstrip::OnMouseReleased(const views::MouseEvent& event,
                                                 bool canceled) {
+  StopHandleTimer();
   if (dragging_) {
+    // Drop the toolstrip roughly where it is now.
     views::View::OnMouseReleased(event, canceled);
     dragging_ = false;
     // |this| and |shelf_| are in different view hierarchies, so we need to
     // convert to screen coordinates and back again to map locations.
     gfx::Point loc = event.location();
     View::ConvertPointToScreen(this, &loc);
     View::ConvertPointToView(NULL, shelf_, &loc);
     shelf_->DropExtension(this, loc, canceled);
     AttachToShelf(true);
-  } else {
-#if 0
-    // TODO(erikkay) implementation currently in progress
+  } else if (!canceled &&
+             info_->mole.is_valid() && info_->toolstrip.is_valid()) {
+    // Toggle mole to either expanded or collapsed.
     expanded_ = !expanded_;
+    view()->set_is_toolstrip(!expanded_);
     if (expanded_) {
+      gfx::Size extension_size = view()->GetPreferredSize();
+      extension_size.set_height(info_->mole_height);
+      view()->SetPreferredSize(extension_size);
+
+      host_->NavigateToURL(info_->mole);
       StopHandleTimer();
       DetachFromShelf(false);
       LayoutHandle();
     } else {
+      gfx::Size extension_size = view()->GetPreferredSize();
+      extension_size.set_height(25);  // TODO(erikkay) hard-coded?

[Matt Perry, 2009/07/24 23:11:11]

any way we can get this information from the height of the shelf?

[Erik does not do reviews, 2009/07/26 00:34:46]

yeah, I had a constant that I should have been using here anyway.

+      view()->SetPreferredSize(extension_size);
+
+      host_->NavigateToURL(info_->toolstrip);
       AttachToShelf(false);
     }
-#endif
+
+    // This is to prevent flickering as the page loads and lays out.
+    // Once the navigation is finished, ExtensionView will wind up setting
+    // visibility to true.
+    view()->SetVisible(false);
   }
 }
 
 BrowserBubble* ExtensionShelf::Toolstrip::GetHandle() {
   if (!handle_.get()) {
     handle_.reset(new BrowserBubble(this, shelf_->GetWidget(),
                                     gfx::Point(0, 0)));
     handle_->set_delegate(this);
     LayoutHandle();
   }
@@ skipping 12 matching lines @@
                                     &origin);
   } else {
     views::View::ConvertPointToWidget(view(), &origin);
   }
   SetBounds(0, 0, handle_width, height());
   handle_->SetBounds(origin.x(), origin.y(), handle_width, height());
   handle_->ResizeToView();
 }
 
 void ExtensionShelf::Toolstrip::ChildPreferredSizeChanged(View* child) {
-  if (child == view())
+  if (child == view()) {
     child->SizeToPreferredSize();
+    Layout();
+  }
 }
 
 void ExtensionShelf::Toolstrip::BubbleBrowserWindowMoved(BrowserBubble* bubble)
 {
   HideShelfHandle(0);
 }
 
-void ExtensionShelf::Toolstrip::BubbleBrowserWindowClosed(BrowserBubble* bubble)
+void ExtensionShelf::Toolstrip::BubbleBrowserWindowClosing(BrowserBubble* bubble)
 {
-  HideShelfHandle(0);
+  DoHideShelfHandle();
 }
 
 void ExtensionShelf::Toolstrip::DetachFromShelf(bool browserDetach) {
   DCHECK(!placeholder_view_);
   if (browserDetach && handle_->attached())
     handle_->DetachFromBrowser();
 
   // Construct a placeholder view to replace the view.
   placeholder_view_ = new PlaceholderView();
   placeholder_view_->SetBounds(view()->bounds());
@@ skipping 28 matching lines @@
 
 void ExtensionShelf::Toolstrip::DoShowShelfHandle() {
   GetHandle();
   if (!handle_->visible()) {
     LayoutHandle();
     handle_->Show();
   }
 }
 
 void ExtensionShelf::Toolstrip::DoHideShelfHandle() {
-  if (!handle_visible() || dragging_ || expanded_)
+  if (!handle_visible())
     return;
   handle_->Hide();
   if (handle_->attached())
     handle_->DetachFromBrowser();
   handle_.reset(NULL);
 }
 
 void ExtensionShelf::Toolstrip::StopHandleTimer() {
   if (!timer_factory_.empty())
     timer_factory_.RevokeAll();
@@ skipping 136 matching lines @@
     name->assign(accessible_name_);
     return true;
   }
   return false;
 }
 
 void ExtensionShelf::SetAccessibleName(const std::wstring& name) {
   accessible_name_.assign(name);
 }
 
-void ExtensionShelf::ToolstripInsertedAt(ExtensionHost* host, int index) {
-  model_->SetToolstripDataAt(index, new Toolstrip(this, host));
+void ExtensionShelf::ToolstripInsertedAt(ExtensionHost* host,
+                                         int index) {
+  model_->SetToolstripDataAt(index,
+      new Toolstrip(this, host, model_->ToolstripInfoAt(index)));
 
   bool had_views = GetChildViewCount() > 0;
   ExtensionView* view = host->view();
   if (!background_.empty())
     view->SetBackground(background_);
   AddChildView(view);
   view->SetContainer(this);
   if (!had_views)
     PreferredSizeChanged();
   Layout();
@@ skipping 129 matching lines @@
   }
   NOTREACHED();
   return NULL;
 }
 
 void ExtensionShelf::LoadFromModel() {
   int count = model_->count();
   for (int i = 0; i < count; ++i)
     ToolstripInsertedAt(model_->ToolstripAt(i), i);
 }