chrome: Rename WrenchMenuModel to AppMenuModel.

chrome/browser/ui/toolbar/wrench_menu_model_unittest.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 "chrome/browser/ui/toolbar/app_menu_model.h"
 
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/global_error/global_error.h"
 #include "chrome/browser/ui/global_error/global_error_service.h"
 #include "chrome/browser/ui/global_error/global_error_service_factory.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
@@ skipping 30 matching lines @@
 
  private:
   int command_id_;
   int execute_count_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuError);
 };
 
 } // namespace
 
-class WrenchMenuModelTest : public BrowserWithTestWindowTest,
-                            public ui::AcceleratorProvider {
+class AppMenuModelTest : public BrowserWithTestWindowTest,
+                         public ui::AcceleratorProvider {
  public:
   // Don't handle accelerators.
   bool GetAcceleratorForCommandId(int command_id,
                                   ui::Accelerator* accelerator) override {
     return false;
   }
 
  protected:
   void SetUp() override {
     prefs_.reset(new TestingPrefServiceSimple());
@@ skipping 10 matching lines @@
     TestingBrowserProcess::GetGlobal()->SetLocalState(NULL);
     DestroyBrowserAndProfile();
   }
 
  private:
   scoped_ptr<TestingPrefServiceSimple> prefs_;
   scoped_ptr<chrome::TestingIOThreadState> testing_io_thread_state_;
 };
 
 // Copies parts of MenuModelTest::Delegate and combines them with the
-// WrenchMenuModel since WrenchMenuModel is now a SimpleMenuModel::Delegate and
+// AppMenuModel since AppMenuModel is now a SimpleMenuModel::Delegate and
 // not derived from SimpleMenuModel.
-class TestWrenchMenuModel : public WrenchMenuModel {
+class TestAppMenuModel : public AppMenuModel {
  public:
-  TestWrenchMenuModel(ui::AcceleratorProvider* provider,
-                      Browser* browser)
-      : WrenchMenuModel(provider, browser),
+  TestAppMenuModel(ui::AcceleratorProvider* provider, Browser* browser)
+      : AppMenuModel(provider, browser),
         execute_count_(0),
         checked_count_(0),
-        enable_count_(0) {
-  }
+        enable_count_(0) {}
 
   // Testing overrides to ui::SimpleMenuModel::Delegate:
   bool IsCommandIdChecked(int command_id) const override {
-    bool val = WrenchMenuModel::IsCommandIdChecked(command_id);
+    bool val = AppMenuModel::IsCommandIdChecked(command_id);
     if (val)
       checked_count_++;
     return val;
   }
 
   bool IsCommandIdEnabled(int command_id) const override {
     ++enable_count_;
     return true;
   }
 
   void ExecuteCommand(int command_id, int event_flags) override {
     ++execute_count_;
   }
 
   int execute_count_;
   mutable int checked_count_;
   mutable int enable_count_;
 };
 
-TEST_F(WrenchMenuModelTest, Basics) {
-  TestWrenchMenuModel model(this, browser());
+TEST_F(AppMenuModelTest, Basics) {
+  TestAppMenuModel model(this, browser());
   int itemCount = model.GetItemCount();
 
   // Verify it has items. The number varies by platform, so we don't check
   // the exact number.
   EXPECT_GT(itemCount, 10);
 
   UpgradeDetector* detector = UpgradeDetector::GetInstance();
   detector->NotifyUpgradeRecommended();
   EXPECT_TRUE(detector->notify_upgrade());
   EXPECT_EQ(browser_defaults::kShowUpgradeMenuItem,
@@ skipping 33 matching lines @@
   EXPECT_GT(bookmarksModel->GetItemCount(), 1);
 
   // Bookmark manager item.
   bookmarksModel->ActivatedAt(4);
   EXPECT_TRUE(bookmarksModel->IsEnabledAt(4));
   EXPECT_EQ(model.execute_count_, 1);
   EXPECT_EQ(model.enable_count_, 1);
 }
 
 // Tests global error menu items in the wrench menu.
-TEST_F(WrenchMenuModelTest, GlobalError) {
+TEST_F(AppMenuModelTest, GlobalError) {
   // Make sure services required for tests are initialized.
   GlobalErrorService* service =
       GlobalErrorServiceFactory::GetForProfile(browser()->profile());
   ProfileOAuth2TokenServiceFactory::GetForProfile(browser()->profile());
   const int command1 = 1234567;
   // AddGlobalError takes ownership of error1.
   MenuError* error1 = new MenuError(command1);
   service->AddGlobalError(error1);
   const int command2 = 1234568;
   // AddGlobalError takes ownership of error2.
   MenuError* error2 = new MenuError(command2);
   service->AddGlobalError(error2);
 
-  WrenchMenuModel model(this, browser());
+  AppMenuModel model(this, browser());
   int index1 = model.GetIndexOfCommandId(command1);
   EXPECT_GT(index1, -1);
   int index2 = model.GetIndexOfCommandId(command2);
   EXPECT_GT(index2, -1);
 
   EXPECT_TRUE(model.IsEnabledAt(index1));
   EXPECT_EQ(0, error1->execute_count());
   model.ActivatedAt(index1);
   EXPECT_EQ(1, error1->execute_count());
 
   EXPECT_TRUE(model.IsEnabledAt(index2));
   EXPECT_EQ(0, error2->execute_count());
   model.ActivatedAt(index2);
   EXPECT_EQ(1, error1->execute_count());
 }
 
 class EncodingMenuModelTest : public BrowserWithTestWindowTest,
                               public MenuModelTest {
 };
 
 TEST_F(EncodingMenuModelTest, IsCommandIdCheckedWithNoTabs) {
   EncodingMenuModel model(browser());
   ASSERT_EQ(NULL, browser()->tab_strip_model()->GetActiveWebContents());
   EXPECT_FALSE(model.IsCommandIdChecked(IDC_ENCODING_WINDOWS1252));
 }