Remove SWIGged use of BrowserProxy and TabProxy from PyAuto tests.

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 384 matching lines @@
     IPC_MESSAGE_HANDLER(AutomationMsg_Type, GetType)
     IPC_MESSAGE_HANDLER(AutomationMsg_Tab, GetTab)
     IPC_MESSAGE_HANDLER(AutomationMsg_TabTitle, GetTabTitle)
     IPC_MESSAGE_HANDLER(AutomationMsg_TabIndex, GetTabIndex)
     IPC_MESSAGE_HANDLER(AutomationMsg_TabURL, GetTabURL)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_DomOperation,
                                     ExecuteJavascript)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_OpenNewBrowserWindowOfType,
                                     OpenNewBrowserWindowOfType)
     IPC_MESSAGE_HANDLER(AutomationMsg_WindowForBrowser, GetWindowForBrowser)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_WaitForTabToBeRestored,
-                                    WaitForTabToBeRestored)
-    IPC_MESSAGE_HANDLER(AutomationMsg_GetSecurityState, GetSecurityState)
-    IPC_MESSAGE_HANDLER(AutomationMsg_GetPageType, GetPageType)
     IPC_MESSAGE_HANDLER(AutomationMsg_GetMetricEventDuration,
                         GetMetricEventDuration)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_ActionOnSSLBlockingPage,
-                                    ActionOnSSLBlockingPage)
     IPC_MESSAGE_HANDLER(AutomationMsg_BringBrowserToFront, BringBrowserToFront)
     IPC_MESSAGE_HANDLER(AutomationMsg_OpenFindInPage,
                         HandleOpenFindInPageRequest)
     IPC_MESSAGE_HANDLER(AutomationMsg_FindWindowVisibility,
                         GetFindWindowVisibility)
     IPC_MESSAGE_HANDLER(AutomationMsg_BookmarkBarVisibility,
                         GetBookmarkBarVisibility)
     IPC_MESSAGE_HANDLER(AutomationMsg_GetBookmarksAsJSON,
                         GetBookmarksAsJSON)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_WaitForBookmarkModelToLoad,
@@ skipping 779 matching lines @@
 
   if (browser_tracker_->ContainsHandle(browser_handle)) {
     Browser* browser = browser_tracker_->GetResource(browser_handle);
     gfx::NativeWindow win = browser->window()->GetNativeWindow();
     // Add() returns the existing handle for the resource if any.
     *handle = window_tracker_->Add(win);
     *success = true;
   }
 }
 
-void TestingAutomationProvider::WaitForTabToBeRestored(
-    int tab_handle,
-    IPC::Message* reply_message) {
-  if (tab_tracker_->ContainsHandle(tab_handle)) {
-    NavigationController* tab = tab_tracker_->GetResource(tab_handle);
-    restore_tracker_.reset(
-        new NavigationControllerRestoredObserver(this, tab, reply_message));
-  } else {
-    AutomationMsg_WaitForTabToBeRestored::WriteReplyParams(
-        reply_message, false);
-    Send(reply_message);
-  }
-}
-
-void TestingAutomationProvider::GetSecurityState(
-    int handle,
-    bool* success,
-    content::SecurityStyle* security_style,
-    net::CertStatus* ssl_cert_status,
-    int* insecure_content_status) {
-  if (tab_tracker_->ContainsHandle(handle)) {
-    NavigationController* tab = tab_tracker_->GetResource(handle);
-    NavigationEntry* entry = tab->GetActiveEntry();
-    *success = true;
-    *security_style = entry->GetSSL().security_style;
-    *ssl_cert_status = entry->GetSSL().cert_status;
-    *insecure_content_status = entry->GetSSL().content_status;
-  } else {
-    *success = false;
-    *security_style = content::SECURITY_STYLE_UNKNOWN;
-    *ssl_cert_status = 0;
-    *insecure_content_status = 0;
-  }
-}
-
-void TestingAutomationProvider::GetPageType(
-    int handle,
-    bool* success,
-    content::PageType* page_type) {
-  if (tab_tracker_->ContainsHandle(handle)) {
-    NavigationController* tab = tab_tracker_->GetResource(handle);
-    NavigationEntry* entry = tab->GetActiveEntry();
-    *page_type = entry->GetPageType();
-    *success = true;
-    // In order to return the proper result when an interstitial is shown and
-    // no navigation entry were created for it we need to ask the WebContents.
-    if (*page_type == content::PAGE_TYPE_NORMAL &&
-        tab->GetWebContents()->ShowingInterstitialPage())
-      *page_type = content::PAGE_TYPE_INTERSTITIAL;
-  } else {
-    *success = false;
-    *page_type = content::PAGE_TYPE_NORMAL;
-  }
-}
-
 void TestingAutomationProvider::GetMetricEventDuration(
     const std::string& event_name,
     int* duration_ms) {
   *duration_ms = metric_event_duration_observer_->GetEventDurationMs(
       event_name);
 }
 
-void TestingAutomationProvider::ActionOnSSLBlockingPage(
-    int handle,
-    bool proceed,
-    IPC::Message* reply_message) {
-  if (tab_tracker_->ContainsHandle(handle)) {
-    NavigationController* tab = tab_tracker_->GetResource(handle);
-    NavigationEntry* entry = tab->GetActiveEntry();
-    if (entry->GetPageType() == content::PAGE_TYPE_INTERSTITIAL) {
-      WebContents* web_contents = tab->GetWebContents();
-      InterstitialPage* ssl_blocking_page =
-          InterstitialPage::GetInterstitialPage(web_contents);
-      if (ssl_blocking_page) {
-        if (proceed) {
-          new NavigationNotificationObserver(tab, this, reply_message, 1,
-                                             false, false);
-          ssl_blocking_page->Proceed();
-          return;
-        }
-        ssl_blocking_page->DontProceed();
-        AutomationMsg_ActionOnSSLBlockingPage::WriteReplyParams(
-            reply_message, AUTOMATION_MSG_NAVIGATION_SUCCESS);
-        Send(reply_message);
-        return;
-      }
-    }
-  }
-  // We failed.
-  AutomationMsg_ActionOnSSLBlockingPage::WriteReplyParams(
-      reply_message, AUTOMATION_MSG_NAVIGATION_ERROR);
-  Send(reply_message);
-}
-
 void TestingAutomationProvider::BringBrowserToFront(int browser_handle,
                                                     bool* success) {
   *success = false;
   if (browser_tracker_->ContainsHandle(browser_handle)) {
     Browser* browser = browser_tracker_->GetResource(browser_handle);
     browser->window()->Activate();
     *success = true;
   }
 }
 
@@ skipping 377 matching lines @@
   handler_map_["SendOSLevelKeyEventToTab"] =
       &TestingAutomationProvider::SendOSLevelKeyEventToTab;
   handler_map_["ProcessWebMouseEvent"] =
       &TestingAutomationProvider::ProcessWebMouseEvent;
   handler_map_["ActivateTab"] =
       &TestingAutomationProvider::ActivateTabJSON;
   handler_map_["GetAppModalDialogMessage"] =
       &TestingAutomationProvider::GetAppModalDialogMessage;
   handler_map_["AcceptOrDismissAppModalDialog"] =
       &TestingAutomationProvider::AcceptOrDismissAppModalDialog;
+  handler_map_["ActionOnSSLBlockingPage"] =
+      &TestingAutomationProvider::ActionOnSSLBlockingPage;
+  handler_map_["GetSecurityState"] =
+      &TestingAutomationProvider::GetSecurityState;
   handler_map_["GetChromeDriverAutomationVersion"] =
       &TestingAutomationProvider::GetChromeDriverAutomationVersion;
   handler_map_["IsPageActionVisible"] =
       &TestingAutomationProvider::IsPageActionVisible;
   handler_map_["CreateNewAutomationProvider"] =
       &TestingAutomationProvider::CreateNewAutomationProvider;
   handler_map_["GetBrowserInfo"] =
       &TestingAutomationProvider::GetBrowserInfo;
   handler_map_["GetTabInfo"] =
       &TestingAutomationProvider::GetTabInfo;
@@ skipping 361 matching lines @@
   // Look for command in handlers that take a Browser.
   if (browser_handler_map_.find(std::string(command)) !=
       browser_handler_map_.end() && browser) {
     (this->*browser_handler_map_[command])(browser, dict_value.get(),
                                            reply_message);
   // Look for command in handlers that don't take a Browser.
   } else if (handler_map_.find(std::string(command)) != handler_map_.end()) {
     (this->*handler_map_[command])(dict_value.get(), reply_message);
   // Command has no handler.
   } else {
-    error_string = "Unknown command. Options: ";
+    error_string = StringPrintf("Unknown command '%s'. Options: ",
+                                command.c_str());
     for (std::map<std::string, JsonHandler>::const_iterator it =
          handler_map_.begin(); it != handler_map_.end(); ++it) {
       error_string += it->first + ", ";
     }
     for (std::map<std::string, BrowserJsonHandler>::const_iterator it =
          browser_handler_map_.begin(); it != browser_handler_map_.end(); ++it) {
       error_string += it->first + ", ";
     }
     AutomationJSONReply(this, reply_message).SendError(error_string);
   }
@@ skipping 2310 matching lines @@
 
   if (action->HasPopup(ExtensionTabUtil::GetTabId(tab))) {
     // This observer will delete itself.
     new ExtensionPopupObserver(
         this, reply_message, extension->id());
   } else {
     AutomationJSONReply(this, reply_message).SendSuccess(NULL);
   }
 }
 
+void TestingAutomationProvider::ActionOnSSLBlockingPage(
+    DictionaryValue* args,
+    IPC::Message* reply_message) {
+  WebContents* web_contents;
+  bool proceed;
+  std::string error;
+  if (!GetTabFromJSONArgs(args, &web_contents, &error)) {
+    AutomationJSONReply(this, reply_message).SendError(error);
+    return;
+  }
+  if (!args->GetBoolean("proceed", &proceed)) {
+    AutomationJSONReply(this, reply_message).SendError(
+        "'proceed' is missing or invalid");
+    return;
+  }
+  NavigationController& controller = web_contents->GetController();
+  NavigationEntry* entry = controller.GetActiveEntry();
+  if (entry->GetPageType() == content::PAGE_TYPE_INTERSTITIAL) {
+    InterstitialPage* ssl_blocking_page =
+        InterstitialPage::GetInterstitialPage(web_contents);
+    if (ssl_blocking_page) {
+      if (proceed) {
+        new NavigationNotificationObserver(&controller, this, reply_message, 1,
+                                           false, true);
+        ssl_blocking_page->Proceed();
+        return;
+      }
+      ssl_blocking_page->DontProceed();
+      AutomationJSONReply(this, reply_message).SendSuccess(NULL);
+      return;
+    }
+  }
+  AutomationJSONReply(this, reply_message).SendError(error);
+}
+
+void TestingAutomationProvider::GetSecurityState(DictionaryValue* args,
+                                                 IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+  WebContents* web_contents;
+  std::string error;
+  if (!GetTabFromJSONArgs(args, &web_contents, &error)) {
+    reply.SendError(error);
+    return;
+  }
+  NavigationEntry* entry = web_contents->GetController().GetActiveEntry();
+  DictionaryValue dict;
+  dict.SetInteger("security_style",
+                  static_cast<int>(entry->GetSSL().security_style));
+  dict.SetInteger("ssl_cert_status",
+                  static_cast<int>(entry->GetSSL().cert_status));
+  dict.SetInteger("insecure_content_status",
+                  static_cast<int>(entry->GetSSL().content_status));
+  reply.SendSuccess(&dict);
+}
+
 // Sample json input: { "command": "UpdateExtensionsNow" }
 // Sample json output: {}
 void TestingAutomationProvider::UpdateExtensionsNow(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   std::string error;
   Browser* browser;
   if (!GetBrowserFromJSONArgs(args, &browser, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
@@ skipping 1580 matching lines @@
   if (AppModalDialogQueue::GetInstance()->HasActiveDialog()) {
     AutomationJSONReply(this, reply_message).SendSuccess(NULL);
     return;
   }
 
   // This class will send the message immediately if no tab is loading.
   new AllViewsStoppedLoadingObserver(
       this, reply_message, profile()->GetExtensionProcessManager());
 }
 
+void TestingAutomationProvider::WaitForTabToBeRestored(
+    DictionaryValue* args,
+    IPC::Message* reply_message) {
+  WebContents* web_contents;
+  std::string error;
+  if (!GetTabFromJSONArgs(args, &web_contents, &error)) {
+    AutomationJSONReply(this, reply_message).SendError(error);
+    return;
+  }
+  NavigationController& controller = web_contents->GetController();
+  new NavigationControllerRestoredObserver(this, &controller, reply_message);
+}
+
 void TestingAutomationProvider::GetPolicyDefinitionList(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
 
 #if !defined(ENABLE_CONFIGURATION_POLICY)
   reply.SendError("Configuration Policy disabled");
 #else
   DictionaryValue response;
 
@@ skipping 130 matching lines @@
   if (!args->GetString("url", &url)) {
     AutomationJSONReply(this, reply_message)
         .SendError("'url' missing or invalid");
     return;
   }
   if (!args->GetInteger("navigation_count", &navigation_count)) {
     AutomationJSONReply(this, reply_message)
         .SendError("'navigation_count' missing or invalid");
     return;
   }
-  new NavigationNotificationObserver(
-      &web_contents->GetController(), this, reply_message,
-      navigation_count, false, true);
+  if (navigation_count > 0) {
+    new NavigationNotificationObserver(
+        &web_contents->GetController(), this, reply_message,
+        navigation_count, false, true);
+  } else {
+    AutomationJSONReply(this, reply_message).SendSuccess(NULL);
+  }
   OpenURLParams params(
       GURL(url), content::Referrer(), CURRENT_TAB,
       content::PageTransitionFromInt(
           content::PAGE_TRANSITION_TYPED |
           content::PAGE_TRANSITION_FROM_ADDRESS_BAR),
       false);
   browser->OpenURLFromTab(web_contents, params);
 }
 
 void TestingAutomationProvider::GetActiveTabIndexJSON(
@@ skipping 682 matching lines @@
       automation_util::DoesObjectWithIdExist(id, profile()));
   reply.SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::CloseTabJSON(
     DictionaryValue* args, IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   WebContents* tab;
   std::string error;
+  bool wait_until_closed = false; // ChromeDriver does not use this.

[Nirnimesh, 2012/08/07 00:37:35]

nit: need 2 spaces before //

[craigdh, 2012/08/07 21:08:51]

Done.

+  args->GetBoolean("wait_until_closed", &wait_until_closed);
   // Close tabs synchronously.
   if (GetBrowserAndTabFromJSONArgs(args, &browser, &tab, &error)) {
+    if (wait_until_closed) {
+      new TabClosedNotificationObserver(this, wait_until_closed, reply_message,
+                                        true);
+    }
     chrome::CloseWebContents(browser, tab);
-    reply.SendSuccess(NULL);
+    if (!wait_until_closed)
+      reply.SendSuccess(NULL);
     return;
   }
-
   // Close other types of views asynchronously.
   RenderViewHost* view;
   if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     reply.SendError(error);
     return;
   }
   view->ClosePage();
   reply.SendSuccess(NULL);
 }
 
@@ skipping 197 matching lines @@
 void TestingAutomationProvider::OnRemoveProvider() {
   if (g_browser_process)
     g_browser_process->GetAutomationProviderList()->RemoveProvider(this);
 }
 
 void TestingAutomationProvider::EnsureTabSelected(Browser* browser,
                                                   WebContents* tab) {
   if (chrome::GetActiveWebContents(browser) != tab)
     chrome::ActivateTabAt(browser, chrome::GetIndexOfTab(browser, tab), true);
 }