Setting the touch wrench menu as default menu for ChromeOS

chrome/browser/ui/toolbar/wrench_menu_model.cc

 // Copyright (c) 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/toolbar/wrench_menu_model.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/command_line.h"
@@ skipping 38 matching lines @@
 #include "content/public/browser/web_contents.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/layout.h"
 #include "ui/base/models/button_menu_item_model.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
+#include "ui/views/controls/menu/menu_config.h"

[sky, 2012/08/23 16:58:51]

This is views specific, so you'll need to ifdef this.

[Mr4D (OOO till 08-26), 2012/08/23 17:46:31]

Done.

 
 #if defined(TOOLKIT_GTK)
 #include <gtk/gtk.h>
 #include "chrome/browser/ui/gtk/gtk_util.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/metro.h"
 #include "base/win/windows_version.h"
 #include "chrome/browser/enumerate_modules_model_win.h"
@@ skipping 21 matching lines @@
   encoding_menu_controller.GetEncodingMenuItems(browser_->profile(),
                                                 &encoding_menu_items);
 
   int group_id = 0;
   EncodingMenuController::EncodingMenuItemList::iterator it =
       encoding_menu_items.begin();
   for (; it != encoding_menu_items.end(); ++it) {
     int id = it->first;
     string16& label = it->second;
     if (id == 0) {
-      AddSeparator();
+      AddSeparator(ui::NORMAL_SEPARATOR);
     } else {
       if (id == IDC_ENCODING_AUTO_DETECT) {
         AddCheckItem(id, label);
       } else {
         // Use the id of the first radio command as the id of the group.
         if (group_id <= 0)
           group_id = id;
         AddRadioItem(id, label, group_id);
       }
     }
@@ skipping 54 matching lines @@
                                Browser* browser)
     : SimpleMenuModel(delegate) {
   Build(browser);
 }
 
 ToolsMenuModel::~ToolsMenuModel() {}
 
 void ToolsMenuModel::Build(Browser* browser) {
 #if !defined(OS_CHROMEOS) && !defined(OS_MACOSX)
   AddItemWithStringId(IDC_CREATE_SHORTCUTS, IDS_CREATE_SHORTCUTS);
-  AddSeparator();
+  AddSeparator(ui::NORMAL_SEPARATOR);
 #endif
 
   AddItemWithStringId(IDC_MANAGE_EXTENSIONS, IDS_SHOW_EXTENSIONS);
 
   if (chrome::CanOpenTaskManager())
     AddItemWithStringId(IDC_TASK_MANAGER, IDS_TASK_MANAGER);
 
   AddItemWithStringId(IDC_CLEAR_BROWSING_DATA, IDS_CLEAR_BROWSING_DATA);
 
-  AddSeparator();
+  AddSeparator(ui::NORMAL_SEPARATOR);
 
 #if !defined(OS_CHROMEOS)
   // Show IDC_FEEDBACK in "Tools" menu for non-ChromeOS platforms.
   AddItemWithStringId(IDC_FEEDBACK, IDS_FEEDBACK);
-  AddSeparator();
+  AddSeparator(ui::NORMAL_SEPARATOR);
 #endif
 
   encoding_menu_model_.reset(new EncodingMenuModel(browser));
   AddSubMenuWithStringId(IDC_ENCODING_MENU, IDS_ENCODING_MENU,
                          encoding_menu_model_.get());
   AddItemWithStringId(IDC_VIEW_SOURCE, IDS_VIEW_SOURCE);
   AddItemWithStringId(IDC_DEV_TOOLS, IDS_DEV_TOOLS);
   AddItemWithStringId(IDC_DEV_TOOLS_CONSOLE, IDS_DEV_TOOLS_CONSOLE);
 
 #if defined(ENABLE_PROFILING) && !defined(NO_TCMALLOC)
-  AddSeparator();
+  AddSeparator(ui::NORMAL_SEPARATOR);
   AddCheckItemWithStringId(IDC_PROFILING_ENABLED, IDS_PROFILING_ENABLED);
 #endif
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WrenchMenuModel
 
 WrenchMenuModel::WrenchMenuModel(ui::AcceleratorProvider* provider,
                                  Browser* browser)
     : ALLOW_THIS_IN_INITIALIZER_LIST(ui::SimpleMenuModel(this)),
@@ skipping 231 matching lines @@
 
 // For testing.
 WrenchMenuModel::WrenchMenuModel()
     : ALLOW_THIS_IN_INITIALIZER_LIST(ui::SimpleMenuModel(this)),
       provider_(NULL),
       browser_(NULL),
       tab_strip_model_(NULL) {
 }
 
 void WrenchMenuModel::Build() {
-  bool is_touch_menu = ui::GetDisplayLayout() == ui::LAYOUT_TOUCH;
+  bool is_new_menu = views::MenuConfig::IsNewMenu();
+  if (is_new_menu)
+    AddSeparator(ui::SPACING_SEPARATOR);
 
   AddItemWithStringId(IDC_NEW_TAB, IDS_NEW_TAB);
   AddItemWithStringId(IDC_NEW_WINDOW, IDS_NEW_WINDOW);
 #if defined(OS_CHROMEOS)
   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kGuestSession))
     AddItemWithStringId(IDC_NEW_INCOGNITO_WINDOW, IDS_NEW_INCOGNITO_WINDOW);
 #else
   AddItemWithStringId(IDC_NEW_INCOGNITO_WINDOW, IDS_NEW_INCOGNITO_WINDOW);
 #endif
 
   AddItemWithStringId(IDC_PIN_TO_START_SCREEN, IDS_PIN_TO_START_SCREEN);
   bookmark_sub_menu_model_.reset(new BookmarkSubMenuModel(this, browser_));
   AddSubMenuWithStringId(IDC_BOOKMARKS_MENU, IDS_BOOKMARKS_MENU,
                          bookmark_sub_menu_model_.get());
 
   // Append the full menu including separators. The final separator only gets
   // appended when this is a touch menu - otherwise it would get added twice.
-  CreateCutCopyPasteMenu(is_touch_menu);
+  CreateCutCopyPasteMenu(is_new_menu);
 
-  if (!is_touch_menu)
-    CreateZoomMenu();
+  if (!is_new_menu)
+    CreateZoomMenu(is_new_menu);
 
   AddItemWithStringId(IDC_SAVE_PAGE, IDS_SAVE_PAGE);
   AddItemWithStringId(IDC_FIND, IDS_FIND);
   AddItemWithStringId(IDC_PRINT, IDS_PRINT);
 
   tools_menu_model_.reset(new ToolsMenuModel(this, browser_));
   // In case of touch this is the last item.
-  if (!is_touch_menu) {
+  if (!is_new_menu) {
     AddSubMenuWithStringId(IDC_ZOOM_MENU, IDS_TOOLS_MENU,
                            tools_menu_model_.get());
   }
 
-  if (is_touch_menu)
-    CreateZoomMenu();
+  if (is_new_menu)
+    CreateZoomMenu(is_new_menu);
   else
-    AddSeparator();
+    AddSeparator(ui::NORMAL_SEPARATOR);
 
   AddItemWithStringId(IDC_SHOW_HISTORY, IDS_SHOW_HISTORY);
   AddItemWithStringId(IDC_SHOW_DOWNLOADS, IDS_SHOW_DOWNLOADS);
-  AddSeparator();
+  AddSeparator(ui::NORMAL_SEPARATOR);
 
   if (browser_defaults::kShowSyncSetupMenuItem &&
       browser_->profile()->GetOriginalProfile()->IsSyncAccessible()) {
     const string16 short_product_name =
         l10n_util::GetStringUTF16(IDS_SHORT_PRODUCT_NAME);
     AddItem(IDC_SHOW_SYNC_SETUP, l10n_util::GetStringFUTF16(
         IDS_SYNC_MENU_PRE_SYNCED_LABEL, short_product_name));
-    AddSeparator();
+    AddSeparator(ui::NORMAL_SEPARATOR);
   }
 
   AddItemWithStringId(IDC_OPTIONS, IDS_SETTINGS);
 
 // On ChromeOS-Touch, we don't want the about/background pages menu options.
 #if defined(OS_CHROMEOS)
-  if (!is_touch_menu)
+  if (!is_new_menu)
 #endif
   {
     AddItem(IDC_ABOUT, l10n_util::GetStringUTF16(IDS_ABOUT));
     string16 num_background_pages = base::FormatNumber(
         TaskManager::GetBackgroundPageCount());
     AddItem(IDC_VIEW_BACKGROUND_PAGES, l10n_util::GetStringFUTF16(
         IDS_VIEW_BACKGROUND_PAGES, num_background_pages));
   }
 
   if (browser_defaults::kShowUpgradeMenuItem)
     AddItem(IDC_UPGRADE_DIALOG, l10n_util::GetStringUTF16(IDS_UPDATE_NOW));
   AddItem(IDC_VIEW_INCOMPATIBILITIES, l10n_util::GetStringUTF16(
       IDS_VIEW_INCOMPATIBILITIES));
 
 #if defined(OS_WIN)
   SetIcon(GetIndexOfCommandId(IDC_VIEW_INCOMPATIBILITIES),
           ui::ResourceBundle::GetSharedInstance().
               GetNativeImageNamed(IDR_CONFLICT_MENU));
 #endif
 
-  if (!is_touch_menu) {
+  if (!is_new_menu) {
     AddItemWithStringId(IDC_HELP_PAGE_VIA_MENU, IDS_HELP_PAGE);
 
     if (browser_defaults::kShowHelpMenuItemIcon) {
       ui::ResourceBundle& rb = ResourceBundle::GetSharedInstance();
       SetIcon(GetIndexOfCommandId(IDC_HELP_PAGE_VIA_MENU),
               rb.GetNativeImageNamed(IDR_HELP_MENU));
     }
   }
 
   if (browser_defaults::kShowFeedbackMenuItem)
     AddItemWithStringId(IDC_FEEDBACK, IDS_FEEDBACK);
 
   AddGlobalErrorMenuItems();
 
-  if (is_touch_menu) {
+  if (is_new_menu) {
     AddSubMenuWithStringId(IDC_ZOOM_MENU, IDS_MORE_TOOLS_MENU,
                            tools_menu_model_.get());
   }
 
   if (browser_defaults::kShowExitMenuItem) {
 #if defined(OS_WIN)
     if (!base::win::IsMetroProcess())
 #endif
     {
-      AddSeparator();
+      AddSeparator(ui::NORMAL_SEPARATOR);
       AddItemWithStringId(IDC_EXIT, IDS_EXIT);
     }
   }
+
+  if (is_new_menu)
+    AddSeparator(ui::SPACING_SEPARATOR);
 }
 
 void WrenchMenuModel::AddGlobalErrorMenuItems() {
   // TODO(sail): Currently we only build the wrench menu once per browser
   // window. This means that if a new error is added after the menu is built
   // it won't show in the existing wrench menu. To fix this we need to some
   // how update the menu if new errors are added.
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   const GlobalErrorService::GlobalErrorList& errors =
       GlobalErrorServiceFactory::GetForProfile(browser_->profile())->errors();
   for (GlobalErrorService::GlobalErrorList::const_iterator
        it = errors.begin(); it != errors.end(); ++it) {
     GlobalError* error = *it;
     if (error->HasMenuItem()) {
       AddItem(error->MenuItemCommandID(), error->MenuItemLabel());
       int icon_id = error->MenuItemIconResourceID();
       if (icon_id) {
         const gfx::Image& image = rb.GetNativeImageNamed(icon_id);
         SetIcon(GetIndexOfCommandId(error->MenuItemCommandID()),
                 image);
       }
     }
   }
 }
 
-void WrenchMenuModel::CreateCutCopyPasteMenu(bool append_final_separator) {
-  AddSeparator();
+void WrenchMenuModel::CreateCutCopyPasteMenu(bool new_menu) {
+  AddSeparator(new_menu ? ui::LOWER_SEPARATOR: ui::NORMAL_SEPARATOR);
 
 #if defined(OS_POSIX) && !defined(TOOLKIT_VIEWS)
   // WARNING: Mac does not use the ButtonMenuItemModel, but instead defines the
   // layout for this menu item in Toolbar.xib. It does, however, use the
   // command_id value from AddButtonItem() to identify this special item.
   edit_menu_item_model_.reset(new ui::ButtonMenuItemModel(IDS_EDIT, this));
   edit_menu_item_model_->AddGroupItemWithStringId(IDC_CUT, IDS_CUT);
   edit_menu_item_model_->AddGroupItemWithStringId(IDC_COPY, IDS_COPY);
   edit_menu_item_model_->AddGroupItemWithStringId(IDC_PASTE, IDS_PASTE);
   AddButtonItem(IDC_EDIT_MENU, edit_menu_item_model_.get());
 #else
   // WARNING: views/wrench_menu assumes these items are added in this order. If
   // you change the order you'll need to update wrench_menu as well.
   AddItemWithStringId(IDC_CUT, IDS_CUT);
   AddItemWithStringId(IDC_COPY, IDS_COPY);
   AddItemWithStringId(IDC_PASTE, IDS_PASTE);
 #endif
 
-  if (append_final_separator)
-    AddSeparator();
+  if (new_menu)
+    AddSeparator(ui::UPPER_SEPARATOR);
 }
 
-void WrenchMenuModel::CreateZoomMenu() {
+void WrenchMenuModel::CreateZoomMenu(bool new_menu) {
   // This menu needs to be enclosed by separators.
-  AddSeparator();
+  AddSeparator(new_menu ? ui::LOWER_SEPARATOR: ui::NORMAL_SEPARATOR);
 
 #if defined(OS_POSIX) && !defined(TOOLKIT_VIEWS)
   // WARNING: Mac does not use the ButtonMenuItemModel, but instead defines the
   // layout for this menu item in Toolbar.xib. It does, however, use the
   // command_id value from AddButtonItem() to identify this special item.
   zoom_menu_item_model_.reset(
       new ui::ButtonMenuItemModel(IDS_ZOOM_MENU, this));
   zoom_menu_item_model_->AddGroupItemWithStringId(
       IDC_ZOOM_MINUS, IDS_ZOOM_MINUS2);
   zoom_menu_item_model_->AddButtonLabel(IDC_ZOOM_PERCENT_DISPLAY,
                                         IDS_ZOOM_PLUS2);
   zoom_menu_item_model_->AddGroupItemWithStringId(
       IDC_ZOOM_PLUS, IDS_ZOOM_PLUS2);
   zoom_menu_item_model_->AddSpace();
   zoom_menu_item_model_->AddItemWithImage(
       IDC_FULLSCREEN, IDR_FULLSCREEN_MENU_BUTTON);
   AddButtonItem(IDC_ZOOM_MENU, zoom_menu_item_model_.get());
 #else
   // WARNING: views/wrench_menu assumes these items are added in this order. If
   // you change the order you'll need to update wrench_menu as well.
   AddItemWithStringId(IDC_ZOOM_MINUS, IDS_ZOOM_MINUS);
   AddItemWithStringId(IDC_ZOOM_PLUS, IDS_ZOOM_PLUS);
   AddItemWithStringId(IDC_FULLSCREEN, IDS_FULLSCREEN);
 #endif
 
-  AddSeparator();
+  AddSeparator(new_menu ? ui::UPPER_SEPARATOR: ui::NORMAL_SEPARATOR);
 }
 
 void WrenchMenuModel::UpdateZoomControls() {
   bool enable_increment = false;
   bool enable_decrement = false;
   int zoom_percent = 100;
   if (chrome::GetActiveWebContents(browser_)) {
     zoom_percent = chrome::GetActiveWebContents(browser_)->GetZoomPercent(
         &enable_increment, &enable_decrement);
   }
   zoom_label_ = l10n_util::GetStringFUTF16(
       IDS_ZOOM_PERCENT, base::IntToString16(zoom_percent));
 }
 
 string16 WrenchMenuModel::GetSyncMenuLabel() const {
   Profile* profile = browser_->profile()->GetOriginalProfile();
   return sync_ui_util::GetSyncMenuLabel(
       ProfileSyncServiceFactory::GetForProfile(profile),
       *SigninManagerFactory::GetForProfile(profile));
 }