chrome/test/automation/tab_proxy.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/test/automation/tab_proxy.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/json/json_string_value_serializer.h"
  10 #include "base/logging.h"
  11 #include "base/strings/string16.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "base/threading/platform_thread.h"
  14 #include "chrome/common/automation_constants.h"
  15 #include "chrome/common/automation_messages.h"
  16 #include "chrome/test/automation/automation_proxy.h"
  17 #include "chrome/test/automation/browser_proxy.h"
  18 #include "url/gurl.h"
  19
  20 TabProxy::TabProxy(AutomationMessageSender* sender,
  21                    AutomationHandleTracker* tracker,
  22                    int handle)
  23     : AutomationResourceProxy(tracker, sender, handle) {
  24 }
  25
  26 bool TabProxy::GetTabTitle(std::wstring* title) const {
  27   if (!is_valid())
  28     return false;
  29
  30   if (!title) {
  31     NOTREACHED();
  32     return false;
  33   }
  34
  35   int tab_title_size_response = 0;
  36
  37   bool succeeded = sender_->Send(
  38       new AutomationMsg_TabTitle(handle_, &tab_title_size_response, title));
  39   return succeeded;
  40 }
  41
  42 bool TabProxy::GetTabIndex(int* index) const {
  43   if (!is_valid())
  44     return false;
  45
  46   if (!index) {
  47     NOTREACHED();
  48     return false;
  49   }
  50
  51   return sender_->Send(new AutomationMsg_TabIndex(handle_, index));
  52 }
  53
  54 int TabProxy::FindInPage(const std::wstring& search_string,
  55                          FindInPageDirection forward,
  56                          FindInPageCase match_case,
  57                          bool find_next,
  58                          int* ordinal) {
  59   if (!is_valid())
  60     return -1;
  61
  62   AutomationMsg_Find_Params params;
  63   params.search_string = WideToUTF16Hack(search_string);
  64   params.find_next = find_next;
  65   params.match_case = (match_case == CASE_SENSITIVE);
  66   params.forward = (forward == FWD);
  67
  68   int matches = 0;
  69   int ordinal2 = 0;
  70   bool succeeded = sender_->Send(new AutomationMsg_Find(handle_,
  71                                                         params,
  72                                                         &ordinal2,
  73                                                         &matches));
  74   if (!succeeded)
  75     return -1;
  76   if (ordinal)
  77     *ordinal = ordinal2;
  78   return matches;
  79 }
  80
  81 AutomationMsg_NavigationResponseValues TabProxy::NavigateToURL(
  82     const GURL& url) {
  83   return NavigateToURLBlockUntilNavigationsComplete(url, 1);
  84 }
  85
  86 AutomationMsg_NavigationResponseValues
  87     TabProxy::NavigateToURLBlockUntilNavigationsComplete(
  88         const GURL& url, int number_of_navigations) {
  89   if (!is_valid())
  90     return AUTOMATION_MSG_NAVIGATION_ERROR;
  91
  92   AutomationMsg_NavigationResponseValues navigate_response =
  93       AUTOMATION_MSG_NAVIGATION_ERROR;
  94
  95  sender_->Send(new AutomationMsg_NavigateToURLBlockUntilNavigationsComplete(
  96       handle_, url, number_of_navigations, &navigate_response));
  97
  98   return navigate_response;
  99 }
 100
 101 AutomationMsg_NavigationResponseValues TabProxy::GoBack() {
 102   return GoBackBlockUntilNavigationsComplete(1);
 103 }
 104
 105 AutomationMsg_NavigationResponseValues
 106     TabProxy::GoBackBlockUntilNavigationsComplete(int number_of_navigations) {
 107   if (!is_valid())
 108     return AUTOMATION_MSG_NAVIGATION_ERROR;
 109
 110   AutomationMsg_NavigationResponseValues navigate_response =
 111       AUTOMATION_MSG_NAVIGATION_ERROR;
 112   sender_->Send(new AutomationMsg_GoBackBlockUntilNavigationsComplete(
 113       handle_, number_of_navigations, &navigate_response));
 114   return navigate_response;
 115 }
 116
 117 AutomationMsg_NavigationResponseValues TabProxy::GoForward() {
 118   return GoForwardBlockUntilNavigationsComplete(1);
 119 }
 120
 121 AutomationMsg_NavigationResponseValues
 122     TabProxy::GoForwardBlockUntilNavigationsComplete(
 123         int number_of_navigations) {
 124   if (!is_valid())
 125     return AUTOMATION_MSG_NAVIGATION_ERROR;
 126
 127   AutomationMsg_NavigationResponseValues navigate_response =
 128       AUTOMATION_MSG_NAVIGATION_ERROR;
 129   sender_->Send(new AutomationMsg_GoForwardBlockUntilNavigationsComplete(
 130       handle_, number_of_navigations, &navigate_response));
 131   return navigate_response;
 132 }
 133
 134 AutomationMsg_NavigationResponseValues TabProxy::Reload() {
 135   if (!is_valid())
 136     return AUTOMATION_MSG_NAVIGATION_ERROR;
 137
 138   AutomationMsg_NavigationResponseValues navigate_response =
 139       AUTOMATION_MSG_NAVIGATION_ERROR;
 140   sender_->Send(new AutomationMsg_Reload(handle_, &navigate_response));
 141   return navigate_response;
 142 }
 143
 144 bool TabProxy::GetCurrentURL(GURL* url) const {
 145   if (!is_valid())
 146     return false;
 147
 148   if (!url) {
 149     NOTREACHED();
 150     return false;
 151   }
 152
 153   bool succeeded = false;
 154   sender_->Send(new AutomationMsg_TabURL(handle_, &succeeded, url));
 155   return succeeded;
 156 }
 157
 158 bool TabProxy::NavigateToURLAsync(const GURL& url) {
 159   if (!is_valid())
 160     return false;
 161
 162   bool status = false;
 163   sender_->Send(new AutomationMsg_NavigationAsync(handle_,
 164                                                   url,
 165                                                   &status));
 166   return status;
 167 }
 168
 169 bool TabProxy::ExecuteAndExtractString(const std::wstring& frame_xpath,
 170                                        const std::wstring& jscript,
 171                                        std::wstring* string_value) {
 172   scoped_ptr<Value> root(ExecuteAndExtractValue(frame_xpath, jscript));
 173   if (root == NULL)
 174     return false;
 175
 176   DCHECK(root->IsType(Value::TYPE_LIST));
 177   Value* value = NULL;
 178   bool succeeded = static_cast<ListValue*>(root.get())->Get(0, &value);
 179   if (succeeded) {
 180     string16 read_value;
 181     succeeded = value->GetAsString(&read_value);
 182     if (succeeded) {
 183       // TODO(viettrungluu): remove conversion. (But should |jscript| be UTF-8?)
 184       *string_value = UTF16ToWideHack(read_value);
 185     }
 186   }
 187   return succeeded;
 188 }
 189
 190 bool TabProxy::ExecuteAndExtractBool(const std::wstring& frame_xpath,
 191                                      const std::wstring& jscript,
 192                                      bool* bool_value) {
 193   scoped_ptr<Value> root(ExecuteAndExtractValue(frame_xpath, jscript));
 194   if (root == NULL)
 195     return false;
 196
 197   bool read_value = false;
 198   DCHECK(root->IsType(Value::TYPE_LIST));
 199   Value* value = NULL;
 200   bool succeeded = static_cast<ListValue*>(root.get())->Get(0, &value);
 201   if (succeeded) {
 202     succeeded = value->GetAsBoolean(&read_value);
 203     if (succeeded) {
 204       *bool_value = read_value;
 205     }
 206   }
 207   return succeeded;
 208 }
 209
 210 bool TabProxy::ExecuteAndExtractInt(const std::wstring& frame_xpath,
 211                                     const std::wstring& jscript,
 212                                     int* int_value) {
 213   scoped_ptr<Value> root(ExecuteAndExtractValue(frame_xpath, jscript));
 214   if (root == NULL)
 215     return false;
 216
 217   int read_value = 0;
 218   DCHECK(root->IsType(Value::TYPE_LIST));
 219   Value* value = NULL;
 220   bool succeeded = static_cast<ListValue*>(root.get())->Get(0, &value);
 221   if (succeeded) {
 222     succeeded = value->GetAsInteger(&read_value);
 223     if (succeeded) {
 224       *int_value = read_value;
 225     }
 226   }
 227   return succeeded;
 228 }
 229
 230 Value* TabProxy::ExecuteAndExtractValue(const std::wstring& frame_xpath,
 231                                         const std::wstring& jscript) {
 232   if (!is_valid())
 233     return NULL;
 234
 235   std::string json;
 236   if (!sender_->Send(new AutomationMsg_DomOperation(handle_, frame_xpath,
 237                                                     jscript, &json))) {
 238     return NULL;
 239   }
 240   // Wrap |json| in an array before deserializing because valid JSON has an
 241   // array or an object as the root.
 242   json.insert(0, "[");
 243   json.append("]");
 244
 245   JSONStringValueSerializer deserializer(json);
 246   return deserializer.Deserialize(NULL, NULL);
 247 }
 248
 249 bool TabProxy::GetCookies(const GURL& url, std::string* cookies) {
 250   if (!is_valid())
 251     return false;
 252
 253   int size = 0;
 254   return sender_->Send(new AutomationMsg_GetCookies(url, handle_, &size,
 255                                                     cookies));
 256 }
 257
 258 bool TabProxy::GetCookieByName(const GURL& url,
 259                                const std::string& name,
 260                                std::string* cookie) {
 261   std::string cookies;
 262   if (!GetCookies(url, &cookies))
 263     return false;
 264
 265   std::string namestr = name + "=";
 266   std::string::size_type idx = cookies.find(namestr);
 267   if (idx != std::string::npos) {
 268     cookies.erase(0, idx + namestr.length());
 269     *cookie = cookies.substr(0, cookies.find(";"));
 270   } else {
 271     cookie->clear();
 272   }
 273
 274   return true;
 275 }
 276
 277 bool TabProxy::Close() {
 278   return Close(false);
 279 }
 280
 281 bool TabProxy::Close(bool wait_until_closed) {
 282   if (!is_valid())
 283     return false;
 284
 285   bool succeeded = false;
 286   sender_->Send(new AutomationMsg_CloseTab(handle_, wait_until_closed,
 287                                            &succeeded));
 288   return succeeded;
 289 }
 290
 291 #if defined(OS_WIN)
 292 bool TabProxy::ProcessUnhandledAccelerator(const MSG& msg) {
 293   if (!is_valid())
 294     return false;
 295
 296   return sender_->Send(
 297       new AutomationMsg_ProcessUnhandledAccelerator(handle_, msg));
 298   // This message expects no response
 299 }
 300
 301 bool TabProxy::SetInitialFocus(bool reverse, bool restore_focus_to_view) {
 302   if (!is_valid())
 303     return false;
 304
 305   return sender_->Send(
 306       new AutomationMsg_SetInitialFocus(handle_, reverse,
 307                                         restore_focus_to_view));
 308   // This message expects no response
 309 }
 310
 311 AutomationMsg_NavigationResponseValues TabProxy::NavigateInExternalTab(
 312     const GURL& url, const GURL& referrer) {
 313   if (!is_valid())
 314     return AUTOMATION_MSG_NAVIGATION_ERROR;
 315
 316   AutomationMsg_NavigationResponseValues rv = AUTOMATION_MSG_NAVIGATION_ERROR;
 317   sender_->Send(new AutomationMsg_NavigateInExternalTab(handle_, url,
 318                                                         referrer, &rv));
 319   return rv;
 320 }
 321
 322 AutomationMsg_NavigationResponseValues TabProxy::NavigateExternalTabAtIndex(
 323     int index) {
 324   if (!is_valid())
 325     return AUTOMATION_MSG_NAVIGATION_ERROR;
 326
 327   AutomationMsg_NavigationResponseValues rv = AUTOMATION_MSG_NAVIGATION_ERROR;
 328   sender_->Send(new AutomationMsg_NavigateExternalTabAtIndex(handle_, index,
 329                                                              &rv));
 330   return rv;
 331 }
 332
 333 void TabProxy::HandleMessageFromExternalHost(const std::string& message,
 334                                              const std::string& origin,
 335                                              const std::string& target) {
 336   if (!is_valid())
 337     return;
 338
 339   sender_->Send(
 340       new AutomationMsg_HandleMessageFromExternalHost(
 341           handle_, message, origin, target));
 342 }
 343 #endif  // defined(OS_WIN)
 344
 345 bool TabProxy::PrintAsync() {
 346   if (!is_valid())
 347     return false;
 348
 349   return sender_->Send(new AutomationMsg_PrintAsync(handle_));
 350 }
 351
 352 bool TabProxy::WaitForInfoBarCount(size_t target_count) {
 353   if (!is_valid())
 354     return false;
 355
 356   bool success = false;
 357   return sender_->Send(new AutomationMsg_WaitForInfoBarCount(
 358       handle_, target_count, &success)) && success;
 359 }
 360
 361 bool TabProxy::OverrideEncoding(const std::string& encoding) {
 362   if (!is_valid())
 363     return false;
 364
 365   bool succeeded = false;
 366   sender_->Send(new AutomationMsg_OverrideEncoding(handle_, encoding,
 367                                                    &succeeded));
 368   return succeeded;
 369 }
 370
 371 #if defined(OS_WIN)
 372 void TabProxy::Reposition(HWND window, HWND window_insert_after, int left,
 373                           int top, int width, int height, int flags,
 374                           HWND parent_window) {
 375   Reposition_Params params;
 376   params.window = window;
 377   params.window_insert_after = window_insert_after;
 378   params.left = left;
 379   params.top = top;
 380   params.width = width;
 381   params.height = height;
 382   params.flags = flags;
 383   params.set_parent = (::IsWindow(parent_window) ? true : false);
 384   params.parent_window = parent_window;
 385   sender_->Send(new AutomationMsg_TabReposition(handle_, params));
 386 }
 387
 388 void TabProxy::SendContextMenuCommand(int selected_command) {
 389   sender_->Send(new AutomationMsg_ForwardContextMenuCommandToChrome(
 390       handle_, selected_command));
 391 }
 392
 393 void TabProxy::OnHostMoved() {
 394   sender_->Send(new AutomationMsg_BrowserMove(handle_));
 395 }
 396 #endif  // defined(OS_WIN)
 397
 398 void TabProxy::SelectAll() {
 399   sender_->Send(new AutomationMsg_SelectAll(handle_));
 400 }
 401
 402 void TabProxy::Cut() {
 403   sender_->Send(new AutomationMsg_Cut(handle_));
 404 }
 405
 406 void TabProxy::Copy() {
 407   sender_->Send(new AutomationMsg_Copy(handle_));
 408 }
 409
 410 void TabProxy::Paste() {
 411   sender_->Send(new AutomationMsg_Paste(handle_));
 412 }
 413
 414 void TabProxy::ReloadAsync() {
 415   sender_->Send(new AutomationMsg_ReloadAsync(handle_));
 416 }
 417
 418 void TabProxy::StopAsync() {
 419   sender_->Send(new AutomationMsg_StopAsync(handle_));
 420 }
 421
 422 void TabProxy::SaveAsAsync() {
 423   sender_->Send(new AutomationMsg_SaveAsAsync(handle_));
 424 }
 425
 426 void TabProxy::JavaScriptStressTestControl(int cmd, int param) {
 427   if (!is_valid())
 428     return;
 429
 430   sender_->Send(new AutomationMsg_JavaScriptStressTestControl(
 431       handle_, cmd, param));
 432 }
 433
 434 void TabProxy::AddObserver(TabProxyDelegate* observer) {
 435   base::AutoLock lock(list_lock_);
 436   observers_list_.AddObserver(observer);
 437 }
 438
 439 void TabProxy::RemoveObserver(TabProxyDelegate* observer) {
 440   base::AutoLock lock(list_lock_);
 441   observers_list_.RemoveObserver(observer);
 442 }
 443
 444 // Called on Channel background thread, if TabMessages filter is installed.
 445 bool TabProxy::OnMessageReceived(const IPC::Message& message) {
 446   base::AutoLock lock(list_lock_);
 447   FOR_EACH_OBSERVER(TabProxyDelegate, observers_list_,
 448                     OnMessageReceived(this, message));
 449   return true;
 450 }
 451
 452 void TabProxy::OnChannelError() {
 453   base::AutoLock lock(list_lock_);
 454   FOR_EACH_OBSERVER(TabProxyDelegate, observers_list_, OnChannelError(this));
 455 }
 456
 457 TabProxy::~TabProxy() {}
 458
 459 void TabProxy::FirstObjectAdded() {
 460   AddRef();
 461 }
 462
 463 void TabProxy::LastObjectRemoved() {
 464   Release();
 465 }