Move command handling and updating off Browser and onto a helper object.

chrome/browser/automation/testing_automation_provider.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/automation/testing_automation_provider.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 616 matching lines @@
       *status = true;
     }
   }
 }
 
 void TestingAutomationProvider::Reload(int handle,
                                        IPC::Message* reply_message) {
   if (tab_tracker_->ContainsHandle(handle)) {
     NavigationController* tab = tab_tracker_->GetResource(handle);
     Browser* browser = FindAndActivateTab(tab);
-    if (browser && browser->command_updater()->IsCommandEnabled(IDC_RELOAD)) {
+    if (chrome::IsCommandEnabled(browser, IDC_RELOAD)) {
       new NavigationNotificationObserver(
           tab, this, reply_message, 1, false, false);
-      chrome::Reload(browser, CURRENT_TAB);
+      chrome::ExecuteCommand(browser, IDC_RELOAD);
       return;
     }
   }
 
   AutomationMsg_Reload::WriteReplyParams(
       reply_message, AUTOMATION_MSG_NAVIGATION_ERROR);
   Send(reply_message);
 }
 
 void TestingAutomationProvider::GetBrowserWindowCount(int* window_count) {
@@ skipping 20 matching lines @@
 
 void TestingAutomationProvider::ExecuteBrowserCommandAsync(int handle,
                                                            int command,
                                                            bool* success) {
   *success = false;
   if (!browser_tracker_->ContainsHandle(handle)) {
     LOG(WARNING) << "Browser tracker does not contain handle: " << handle;
     return;
   }
   Browser* browser = browser_tracker_->GetResource(handle);
-  if (!browser->command_updater()->SupportsCommand(command)) {
+  if (!chrome::SupportsCommand(browser, command)) {
     LOG(WARNING) << "Browser does not support command: " << command;
     return;
   }
-  if (!browser->command_updater()->IsCommandEnabled(command)) {
+  if (!chrome::IsCommandEnabled(browser, command)) {
     LOG(WARNING) << "Browser command not enabled: " << command;
     return;
   }
-  browser->ExecuteCommand(command);
+  chrome::ExecuteCommand(browser, command);
   *success = true;
 }
 
 void TestingAutomationProvider::ExecuteBrowserCommand(
     int handle, int command, IPC::Message* reply_message) {
   // List of commands which just finish synchronously and don't require
   // setting up an observer.
   static const int kSynchronousCommands[] = {
     IDC_HOME,
     IDC_SELECT_NEXT_TAB,
     IDC_SELECT_PREVIOUS_TAB,
     IDC_SHOW_BOOKMARK_MANAGER,
   };
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
-    if (browser->command_updater()->SupportsCommand(command) &&
-        browser->command_updater()->IsCommandEnabled(command)) {
+    if (chrome::SupportsCommand(browser, command) &&
+        chrome::IsCommandEnabled(browser, command)) {
       // First check if we can handle the command without using an observer.
       for (size_t i = 0; i < arraysize(kSynchronousCommands); i++) {
         if (command == kSynchronousCommands[i]) {
-          browser->ExecuteCommand(command);
+          chrome::ExecuteCommand(browser, command);
           AutomationMsg_WindowExecuteCommand::WriteReplyParams(reply_message,
                                                                true);
           Send(reply_message);
           return;
         }
       }
 
       // Use an observer if we have one, otherwise fail.
       if (ExecuteBrowserCommandObserver::CreateAndRegisterObserver(
           this, browser, command, reply_message)) {
-        browser->ExecuteCommand(command);
+        chrome::ExecuteCommand(browser, command);
         return;
       }
     }
   }
   AutomationMsg_WindowExecuteCommand::WriteReplyParams(reply_message, false);
   Send(reply_message);
 }
 
 void TestingAutomationProvider::WindowSimulateMouseMove(
     const IPC::Message& message,
@@ skipping 630 matching lines @@
     *success = true;
   }
 }
 
 void TestingAutomationProvider::IsMenuCommandEnabled(int browser_handle,
                                                      int message_num,
                                                      bool* menu_item_enabled) {
   *menu_item_enabled = false;
   if (browser_tracker_->ContainsHandle(browser_handle)) {
     Browser* browser = browser_tracker_->GetResource(browser_handle);
-    *menu_item_enabled =
-        browser->command_updater()->IsCommandEnabled(message_num);
+    *menu_item_enabled = chrome::IsCommandEnabled(browser, message_num);
   }
 }
 
 void TestingAutomationProvider::HandleOpenFindInPageRequest(
     const IPC::Message& message, int handle) {
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
     chrome::FindInPage(browser, false, false);
   }
 }
@@ skipping 231 matching lines @@
 
   // Set up an observer (it will delete itself).
   new BrowserCountChangeNotificationObserver(target_count, this, reply_message);
 }
 
 void TestingAutomationProvider::GoBackBlockUntilNavigationsComplete(
     int handle, int number_of_navigations, IPC::Message* reply_message) {
   if (tab_tracker_->ContainsHandle(handle)) {
     NavigationController* tab = tab_tracker_->GetResource(handle);
     Browser* browser = FindAndActivateTab(tab);
-    if (browser && browser->command_updater()->IsCommandEnabled(IDC_BACK)) {
+    if (chrome::IsCommandEnabled(browser, IDC_BACK)) {
       new NavigationNotificationObserver(tab, this, reply_message,
                                          number_of_navigations, false, false);
-      chrome::GoBack(browser, CURRENT_TAB);
+      chrome::ExecuteCommand(browser, IDC_BACK);
       return;
     }
   }
 
   AutomationMsg_GoBackBlockUntilNavigationsComplete::WriteReplyParams(
       reply_message, AUTOMATION_MSG_NAVIGATION_ERROR);
   Send(reply_message);
 }
 
 void TestingAutomationProvider::GoForwardBlockUntilNavigationsComplete(
     int handle, int number_of_navigations, IPC::Message* reply_message) {
   if (tab_tracker_->ContainsHandle(handle)) {
     NavigationController* tab = tab_tracker_->GetResource(handle);
     Browser* browser = FindAndActivateTab(tab);
-    if (browser && browser->command_updater()->IsCommandEnabled(IDC_FORWARD)) {
+    if (chrome::IsCommandEnabled(browser, IDC_FORWARD)) {
       new NavigationNotificationObserver(tab, this, reply_message,
                                          number_of_navigations, false, false);
-      chrome::GoForward(browser, CURRENT_TAB);
+      chrome::ExecuteCommand(browser, IDC_FORWARD);
       return;
     }
   }
 
   AutomationMsg_GoForwardBlockUntilNavigationsComplete::WriteReplyParams(
       reply_message, AUTOMATION_MSG_NAVIGATION_ERROR);
   Send(reply_message);
 }
 
 void TestingAutomationProvider::SetShelfVisibility(int handle, bool visible) {
@@ skipping 5078 matching lines @@
     g_browser_process->GetAutomationProviderList()->RemoveProvider(this);
 }
 
 void TestingAutomationProvider::EnsureTabSelected(Browser* browser,
                                                   WebContents* tab) {
   if (browser->GetActiveWebContents() != tab) {
     browser->ActivateTabAt(browser->GetIndexOfController(
         &tab->GetController()), true);
   }
 }