Refactors code for showing bookmark menus so that it can be used by

chrome/browser/ui/views/wrench_menu.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/wrench_menu.h"
 
 #include <cmath>
 
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
+#include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/browser_window.h"
+#include "chrome/browser/ui/views/bookmarks/bookmark_menu_delegate.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/user_metrics.h"
 #include "content/common/notification_observer.h"
 #include "content/common/notification_registrar.h"
 #include "content/common/notification_source.h"
 #include "content/common/notification_type.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "third_party/skia/include/core/SkPaint.h"
@@ skipping 533 matching lines @@
   int zoom_label_width_;
 
   DISALLOW_COPY_AND_ASSIGN(ZoomView);
 };
 
 // WrenchMenu ------------------------------------------------------------------
 
 WrenchMenu::WrenchMenu(Browser* browser)
     : browser_(browser),
       selected_menu_model_(NULL),
-      selected_index_(0) {
+      selected_index_(0),
+      bookmark_menu_(NULL),
+      first_bookmark_command_id_(0) {
 }
 
 void WrenchMenu::Init(ui::MenuModel* model) {
   DCHECK(!root_.get());
   root_.reset(new MenuItemView(this));
   root_->set_has_icons(true);  // We have checks, radios and icons, set this
                                // so we get the taller menu style.
   int next_id = 1;
   PopulateMenu(root_.get(), model, &next_id);
+  first_bookmark_command_id_ = next_id + 1;
 }
 
 void WrenchMenu::RunMenu(views::MenuButton* host) {
   // Up the ref count while the menu is displaying. This way if the window is
   // deleted while we're running we won't prematurely delete the menu.
   // TODO(sky): fix this, the menu should really take ownership of the menu
   // (57890).
   scoped_refptr<WrenchMenu> dont_delete_while_running(this);
   gfx::Point screen_loc;
   views::View::ConvertPointToScreen(host, &screen_loc);
   gfx::Rect bounds(screen_loc, host->size());
   UserMetrics::RecordAction(UserMetricsAction("ShowAppMenu"));
   root_->RunMenuAt(host->GetWindow()->GetNativeWindow(), host, bounds,
       base::i18n::IsRTL() ? MenuItemView::TOPLEFT : MenuItemView::TOPRIGHT,
       true);
+  if (bookmark_menu_delegate_.get()) {
+    BookmarkModel* model = browser_->profile()->GetBookmarkModel();
+    if (model)
+      model->RemoveObserver(this);
+  }
   if (selected_menu_model_)
     selected_menu_model_->ActivatedAt(selected_index_);
 }
 
+std::wstring WrenchMenu::GetTooltipText(int id,
+                                        const gfx::Point& p) {
+  return is_bookmark_command(id) ?
+      bookmark_menu_delegate_->GetTooltipText(id, p) : std::wstring();
+}
+
+bool WrenchMenu::IsTriggerableEvent(views::MenuItemView* menu,
+                                    const views::MouseEvent& e) {
+  return is_bookmark_command(menu->GetCommand()) ?
+      bookmark_menu_delegate_->IsTriggerableEvent(menu, e) :
+      MenuDelegate::IsTriggerableEvent(menu, e);
+}
+
+bool WrenchMenu::GetDropFormats(
+      MenuItemView* menu,
+      int* formats,
+      std::set<ui::OSExchangeData::CustomFormat>* custom_formats) {
+  CreateBookmarkMenu();
+  return bookmark_menu_delegate_.get() &&
+      bookmark_menu_delegate_->GetDropFormats(menu, formats, custom_formats);
+}
+
+bool WrenchMenu::AreDropTypesRequired(MenuItemView* menu) {
+  CreateBookmarkMenu();
+  return bookmark_menu_delegate_.get() &&
+      bookmark_menu_delegate_->AreDropTypesRequired(menu);
+}
+
+bool WrenchMenu::CanDrop(MenuItemView* menu,
+                         const ui::OSExchangeData& data) {
+  CreateBookmarkMenu();
+  return bookmark_menu_delegate_.get() &&
+      bookmark_menu_delegate_->CanDrop(menu, data);
+}
+
+int WrenchMenu::GetDropOperation(
+    MenuItemView* item,
+    const views::DropTargetEvent& event,
+    DropPosition* position) {
+  return is_bookmark_command(item->GetCommand()) ?
+      bookmark_menu_delegate_->GetDropOperation(item, event, position) :
+      ui::DragDropTypes::DRAG_NONE;
+}
+
+int WrenchMenu::OnPerformDrop(MenuItemView* menu,
+                              DropPosition position,
+                              const views::DropTargetEvent& event) {
+  if (!is_bookmark_command(menu->GetCommand()))
+    return ui::DragDropTypes::DRAG_NONE;
+
+  int result = bookmark_menu_delegate_->OnPerformDrop(menu, position, event);
+  return result;
+}
+
+bool WrenchMenu::ShowContextMenu(MenuItemView* source,
+                                 int id,
+                                 const gfx::Point& p,
+                                 bool is_mouse_gesture) {
+  return is_bookmark_command(id) ?
+      bookmark_menu_delegate_->ShowContextMenu(source, id, p,
+                                               is_mouse_gesture) :
+      false;
+}
+
+bool WrenchMenu::CanDrag(MenuItemView* menu) {
+  return is_bookmark_command(menu->GetCommand()) ?
+      bookmark_menu_delegate_->CanDrag(menu) : false;
+}
+
+void WrenchMenu::WriteDragData(MenuItemView* sender,
+                               ui::OSExchangeData* data) {
+  DCHECK(is_bookmark_command(sender->GetCommand()));
+  return bookmark_menu_delegate_->WriteDragData(sender, data);
+}
+
+int WrenchMenu::GetDragOperations(MenuItemView* sender) {
+  return is_bookmark_command(sender->GetCommand()) ?
+      bookmark_menu_delegate_->GetDragOperations(sender) :
+      MenuDelegate::GetDragOperations(sender);
+}
+
+int WrenchMenu::GetMaxWidthForMenu(MenuItemView* menu) {
+  return is_bookmark_command(menu->GetCommand()) ?
+      bookmark_menu_delegate_->GetMaxWidthForMenu(menu) :
+      MenuDelegate::GetMaxWidthForMenu(menu);
+}
+
 bool WrenchMenu::IsItemChecked(int id) const {
+  if (!is_bookmark_command(id))
+    return false;
+
   const Entry& entry = id_to_entry_.find(id)->second;
   return entry.first->IsItemCheckedAt(entry.second);
 }
 
 bool WrenchMenu::IsCommandEnabled(int id) const {
+  if (is_bookmark_command(id))
+    return true;
+
   if (id == 0)
     return false;  // The root item.
 
   const Entry& entry = id_to_entry_.find(id)->second;
   int command_id = entry.first->GetCommandIdAt(entry.second);
   // The items representing the cut (cut/copy/paste) and zoom menu
   // (increment/decrement/reset) are always enabled. The child views of these
   // items enabled state updates appropriately.
   return command_id == IDC_CUT || command_id == IDC_ZOOM_MINUS ||
       entry.first->IsEnabledAt(entry.second);
 }
 
-void WrenchMenu::ExecuteCommand(int id) {
+void WrenchMenu::ExecuteCommand(int id, int mouse_event_flags) {
+  if (is_bookmark_command(id)) {
+    bookmark_menu_delegate_->ExecuteCommand(id, mouse_event_flags);
+    return;
+  }
+
+  // Not a bookmark
   const Entry& entry = id_to_entry_.find(id)->second;
   int command_id = entry.first->GetCommandIdAt(entry.second);
 
   if (command_id == IDC_CUT || command_id == IDC_ZOOM_MINUS) {
     // These items are represented by child views. If ExecuteCommand is invoked
     // it means the user clicked on the area around the buttons and we should
     // not do anyting.
     return;
   }
 
   return entry.first->ActivatedAt(entry.second);
 }
 
 bool WrenchMenu::GetAccelerator(int id, views::Accelerator* accelerator) {
+  if (is_bookmark_command(id))
+    return false;
+
   const Entry& entry = id_to_entry_.find(id)->second;
   int command_id = entry.first->GetCommandIdAt(entry.second);
   if (command_id == IDC_CUT || command_id == IDC_ZOOM_MINUS) {
     // These have special child views; don't show the accelerator for them.
     return false;
   }
 
   ui::Accelerator menu_accelerator;
   if (!entry.first->GetAcceleratorAt(entry.second, &menu_accelerator))
     return false;
 
   *accelerator = views::Accelerator(menu_accelerator.key_code(),
                                     menu_accelerator.modifiers());
   return true;
 }
 
+void WrenchMenu::WillShowMenu(MenuItemView* menu) {
+  if (menu == bookmark_menu_)
+    CreateBookmarkMenu();
+}
+
+void WrenchMenu::BookmarkModelChanged() {
+  root_->Cancel();
+}
+
 WrenchMenu::~WrenchMenu() {
 }
 
 void WrenchMenu::PopulateMenu(MenuItemView* parent,
                               MenuModel* model,
                               int* next_id) {
   int index_offset = model->GetFirstItemIndex(NULL);
   for (int i = 0, max = model->GetItemCount(); i < max; ++i) {
     int index = i + index_offset;
 
     MenuItemView* item =
         AppendMenuItem(parent, model, index, model->GetTypeAt(index), next_id);
 
     if (model->GetTypeAt(index) == MenuModel::TYPE_SUBMENU)
       PopulateMenu(item, model->GetSubmenuModelAt(index), next_id);
 
-    if (model->GetCommandIdAt(index) == IDC_CUT) {
-      DCHECK_EQ(MenuModel::TYPE_COMMAND, model->GetTypeAt(index));
-      DCHECK_LT(i + 2, max);
-      DCHECK_EQ(IDC_COPY, model->GetCommandIdAt(index + 1));
-      DCHECK_EQ(IDC_PASTE, model->GetCommandIdAt(index + 2));
-      item->SetTitle(UTF16ToWide(l10n_util::GetStringUTF16(IDS_EDIT2)));
-      item->AddChildView(
-          new CutCopyPasteView(this, model, index, index + 1, index + 2));
-      i += 2;
-    } else if (model->GetCommandIdAt(index) == IDC_ZOOM_MINUS) {
-      DCHECK_EQ(MenuModel::TYPE_COMMAND, model->GetTypeAt(index));
-      DCHECK_EQ(IDC_ZOOM_PLUS, model->GetCommandIdAt(index + 1));
-      DCHECK_EQ(IDC_FULLSCREEN, model->GetCommandIdAt(index + 2));
-      item->SetTitle(UTF16ToWide(l10n_util::GetStringUTF16(IDS_ZOOM_MENU2)));
-      item->AddChildView(
-          new ZoomView(this, model, index, index + 1, index + 2));
-      i += 2;
+    switch (model->GetCommandIdAt(index)) {
+      case IDC_CUT:
+        DCHECK_EQ(MenuModel::TYPE_COMMAND, model->GetTypeAt(index));
+        DCHECK_LT(i + 2, max);
+        DCHECK_EQ(IDC_COPY, model->GetCommandIdAt(index + 1));
+        DCHECK_EQ(IDC_PASTE, model->GetCommandIdAt(index + 2));
+        item->SetTitle(UTF16ToWide(l10n_util::GetStringUTF16(IDS_EDIT2)));
+        item->AddChildView(
+            new CutCopyPasteView(this, model, index, index + 1, index + 2));
+        i += 2;
+        break;
+
+      case IDC_ZOOM_MINUS:
+        DCHECK_EQ(MenuModel::TYPE_COMMAND, model->GetTypeAt(index));
+        DCHECK_EQ(IDC_ZOOM_PLUS, model->GetCommandIdAt(index + 1));
+        DCHECK_EQ(IDC_FULLSCREEN, model->GetCommandIdAt(index + 2));
+        item->SetTitle(UTF16ToWide(l10n_util::GetStringUTF16(IDS_ZOOM_MENU2)));
+        item->AddChildView(
+            new ZoomView(this, model, index, index + 1, index + 2));
+        i += 2;
+        break;
+
+      case IDC_BOOKMARKS_MENU:
+        DCHECK(!bookmark_menu_);
+        bookmark_menu_ = item;
+        break;
+
+      default:
+        break;
     }
   }
 }
 
 MenuItemView* WrenchMenu::AppendMenuItem(MenuItemView* parent,
                                          MenuModel* model,
                                          int index,
                                          MenuModel::ItemType menu_type,
                                          int* next_id) {
   int id = (*next_id)++;
@@ skipping 13 matching lines @@
   }
 
   return menu_item;
 }
 
 void WrenchMenu::CancelAndEvaluate(MenuModel* model, int index) {
   selected_menu_model_ = model;
   selected_index_ = index;
   root_->Cancel();
 }
+
+void WrenchMenu::CreateBookmarkMenu() {
+  if (bookmark_menu_delegate_.get())
+    return;  // Already created the menu.
+
+  BookmarkModel* model = browser_->profile()->GetBookmarkModel();
+  if (!model->IsLoaded())
+    return;
+
+  model->AddObserver(this);
+  bookmark_menu_delegate_.reset(
+      new BookmarkMenuDelegate(browser_->profile(),
+                               NULL,
+                               browser_->window()->GetNativeHandle(),
+                               first_bookmark_command_id_));
+  bookmark_menu_delegate_->Init(
+      this, bookmark_menu_, model->GetBookmarkBarNode(), 0,
+      BookmarkMenuDelegate::SHOW_OTHER_FOLDER);
+}