chrome: rename more wrench/Wrench occurrencies to appMenu/AppMenu

chrome/browser/ui/cocoa/extensions/browser_action_button_interactive_uitest.mm

 // Copyright 2015 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.
 
 #import <Cocoa/Cocoa.h>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_action_test_util.h"
@@ skipping 138 matching lines @@
 
   void TearDownOnMainThread() override {
     enable_redesign_.reset();
     ToolbarActionsBar::disable_animations_for_testing_ = false;
     ExtensionBrowserTest::TearDownOnMainThread();
   }
 
   ToolbarController* toolbarController() { return toolbarController_; }
   AppMenuController* appMenuController() { return appMenuController_; }
   ToolbarActionsModel* model() { return model_; }
-  NSView* wrenchButton() { return [toolbarController_ wrenchButton]; }
+  NSView* appMenuButton() { return [toolbarController_ appMenuButton]; }
 
  private:
   scoped_ptr<extensions::FeatureSwitch::ScopedOverride> enable_redesign_;
 
   ToolbarController* toolbarController_ = nil;
   AppMenuController* appMenuController_ = nil;
   ToolbarActionsModel* model_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserActionButtonUiTest);
 };
@@ skipping 86 matching lines @@
 
   // Reset the menu helper so we can use it again.
   [menuHelper setMenuOpened:NO];
   [menuHelper setVerify:base::Bind(
       CheckActionIsPoppedOut, actionsController, actionButton)];
 
   // Shrink the visible count to be 0. This should hide the action button.
   model()->SetVisibleIconCount(0);
   EXPECT_EQ(nil, [actionButton superview]);
 
-  // Move the mouse over the app button.
-  MoveMouseToCenter(wrenchButton());
+  // Move the mouse over the app menu button.
+  MoveMouseToCenter(appMenuButton());
 
   {
     // No menu yet (on the browser action).
     EXPECT_FALSE([menuHelper menuOpened]);
     base::RunLoop runLoop;
     // Click on the app menu, and pass in a callback to continue the test in
     // ClickOnOverflowedAction (Due to the blocking nature of Cocoa menus,
     // passing in runLoop.QuitClosure() is not sufficient here.)
     ui_controls::SendMouseEventsNotifyWhenDone(
         ui_controls::LEFT, ui_controls::DOWN | ui_controls::UP,
         base::Bind(&ClickOnOverflowedAction,
                    base::Unretained(toolbarController()),
                    runLoop.QuitClosure()));
     runLoop.Run();
     // The menu should have opened. Note that the menu opened on the main bar's
     // action button, not the overflow's. Since Cocoa doesn't support running
     // a menu-within-a-menu, this is what has to happen.
     EXPECT_TRUE([menuHelper menuOpened]);
   }
 }
 
 // Checks the layout of the overflow bar in the app menu.
-void CheckWrenchMenuLayout(ToolbarController* toolbarController,
-                           int overflowStartIndex,
-                           const std::string& error_message,
-                           const base::Closure& closure) {
+void CheckAppMenuLayout(ToolbarController* toolbarController,
+                        int overflowStartIndex,
+                        const std::string& error_message,
+                        const base::Closure& closure) {
   AppMenuController* appMenuController =
       [toolbarController appMenuController];
   // The app menu should start as open (since that's where the overflowed
   // actions are).
   EXPECT_TRUE([appMenuController isMenuOpen]) << error_message;
   BrowserActionsController* overflowController =
       [appMenuController browserActionsController];
   ASSERT_TRUE(overflowController) << error_message;
 
   ToolbarActionsBar* overflowBar = [overflowController toolbarActionsBar];
@@ skipping 59 matching lines @@
   for (int i = 0; i < kNumExtensions; ++i) {
     scoped_refptr<const extensions::Extension> extension =
         extensions::extension_action_test_util::CreateActionExtension(
             base::StringPrintf("extension%d", i),
             extensions::extension_action_test_util::BROWSER_ACTION);
     extension_service()->AddExtension(extension.get());
   }
   ASSERT_EQ(kNumExtensions, static_cast<int>(model()->toolbar_items().size()));
 
   // A helper function to open the app menu and call the check function.
-  auto resizeAndActivateWrench = [this](int visible_count,
-                                        const std::string& error_message) {
+  auto resizeAndActivateAppMenu = [this](int visible_count,
+                                         const std::string& error_message) {
     model()->SetVisibleIconCount(kNumExtensions - visible_count);
-    MoveMouseToCenter(wrenchButton());
+    MoveMouseToCenter(appMenuButton());
 
     {
       base::RunLoop runLoop;
       // Click on the app menu, and pass in a callback to continue the test in
-      // CheckWrenchMenuLayout (due to the blocking nature of Cocoa menus,
+      // CheckAppMenuLayout (due to the blocking nature of Cocoa menus,
       // passing in runLoop.QuitClosure() is not sufficient here.)
       ui_controls::SendMouseEventsNotifyWhenDone(
           ui_controls::LEFT, ui_controls::DOWN | ui_controls::UP,
-          base::Bind(&CheckWrenchMenuLayout,
+          base::Bind(&CheckAppMenuLayout,
                      base::Unretained(toolbarController()),
                      kNumExtensions - visible_count,
                      error_message,
                      runLoop.QuitClosure()));
       runLoop.Run();
     }
   };
 
   // Test the layout with gradually more extensions hidden.
   for (int i = 1; i <= kNumExtensions; ++i)
-    resizeAndActivateWrench(i, base::StringPrintf("Normal: %d", i));
+    resizeAndActivateAppMenu(i, base::StringPrintf("Normal: %d", i));
 
   // Adding a global error adjusts the app menu size, and has been known to mess
   // up the overflow container's bounds (crbug.com/511326).
   GlobalErrorService* error_service =
       GlobalErrorServiceFactory::GetForProfile(profile());
   error_service->AddGlobalError(new MenuError());
 
   // It's probably excessive to test every level of the overflow here. Test
   // having all actions overflowed, some actions overflowed, and one action
   // overflowed.
-  resizeAndActivateWrench(kNumExtensions, "GlobalError Full");
-  resizeAndActivateWrench(kNumExtensions / 2, "GlobalError Half");
-  resizeAndActivateWrench(1, "GlobalError One");
+  resizeAndActivateAppMenu(kNumExtensions, "GlobalError Full");
+  resizeAndActivateAppMenu(kNumExtensions / 2, "GlobalError Half");
+  resizeAndActivateAppMenu(1, "GlobalError One");
 }
 
 void AddExtensionWithMenuOpen(ToolbarController* toolbarController,
                               ExtensionService* extensionService,
                               const base::Closure& closure) {
   AppMenuController* appMenuController =
       [toolbarController appMenuController];
 
   scoped_refptr<const extensions::Extension> extension =
       extensions::extension_action_test_util::CreateActionExtension(
@@ skipping 16 matching lines @@
                        DISABLED_AddExtensionWithMenuOpen) {
   // Add an extension to ensure the overflow menu is present.
   scoped_refptr<const extensions::Extension> extension =
       extensions::extension_action_test_util::CreateActionExtension(
           "original extension",
           extensions::extension_action_test_util::BROWSER_ACTION);
   extension_service()->AddExtension(extension.get());
   ASSERT_EQ(1, static_cast<int>(model()->toolbar_items().size()));
   model()->SetVisibleIconCount(0);
 
-  MoveMouseToCenter(wrenchButton());
+  MoveMouseToCenter(appMenuButton());
 
   base::RunLoop runLoop;
   // Click on the app menu, and pass in a callback to continue the test in
   // AddExtensionWithMenuOpen (due to the blocking nature of Cocoa menus,
   // passing in runLoop.QuitClosure() is not sufficient here.)
   ui_controls::SendMouseEventsNotifyWhenDone(
       ui_controls::LEFT, ui_controls::DOWN | ui_controls::UP,
       base::Bind(&AddExtensionWithMenuOpen,
                  base::Unretained(toolbarController()),
                  extension_service(),
                  runLoop.QuitClosure()));
   runLoop.Run();
 }