chrome/test/automation/browser_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/browser_proxy.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/json/json_reader.h"
  10 #include "base/logging.h"
  11 #include "base/threading/platform_thread.h"
  12 #include "base/time/time.h"
  13 #include "chrome/common/automation_constants.h"
  14 #include "chrome/common/automation_messages.h"
  15 #include "chrome/test/automation/automation_proxy.h"
  16 #include "chrome/test/automation/tab_proxy.h"
  17 #include "chrome/test/automation/window_proxy.h"
  18 #include "ui/gfx/point.h"
  19
  20 using base::TimeDelta;
  21 using base::TimeTicks;
  22
  23 bool BrowserProxy::ActivateTab(int tab_index) {
  24   if (!is_valid())
  25     return false;
  26
  27   int activate_tab_response = -1;
  28
  29   if (!sender_->Send(new AutomationMsg_ActivateTab(
  30                          handle_, tab_index, &activate_tab_response))) {
  31     return false;
  32   }
  33
  34   if (activate_tab_response >= 0)
  35     return true;
  36
  37   return false;
  38 }
  39
  40 bool BrowserProxy::BringToFront() {
  41   if (!is_valid())
  42     return false;
  43
  44   bool succeeded = false;
  45
  46   if (!sender_->Send(new AutomationMsg_BringBrowserToFront(
  47                          handle_, &succeeded))) {
  48     return false;
  49   }
  50
  51   return succeeded;
  52 }
  53
  54 bool BrowserProxy::AppendTab(const GURL& tab_url) {
  55   if (!is_valid())
  56     return false;
  57
  58   int append_tab_response = -1;
  59
  60   sender_->Send(new AutomationMsg_AppendTab(handle_, tab_url,
  61                                             &append_tab_response));
  62   return append_tab_response >= 0;
  63 }
  64
  65 bool BrowserProxy::GetActiveTabIndex(int* active_tab_index) const {
  66   if (!is_valid())
  67     return false;
  68
  69   if (!active_tab_index) {
  70     NOTREACHED();
  71     return false;
  72   }
  73
  74   int active_tab_index_response = -1;
  75
  76   if (!sender_->Send(new AutomationMsg_ActiveTabIndex(
  77                          handle_, &active_tab_index_response))) {
  78     return false;
  79   }
  80
  81   if (active_tab_index_response >= 0) {
  82     *active_tab_index = active_tab_index_response;
  83     return true;
  84   }
  85
  86   return false;
  87 }
  88
  89 scoped_refptr<TabProxy> BrowserProxy::GetTab(int tab_index) const {
  90   if (!is_valid())
  91     return NULL;
  92
  93   int tab_handle = 0;
  94
  95   sender_->Send(new AutomationMsg_Tab(handle_, tab_index, &tab_handle));
  96   if (!tab_handle)
  97     return NULL;
  98
  99   TabProxy* tab = static_cast<TabProxy*>(tracker_->GetResource(tab_handle));
 100   if (!tab) {
 101     tab = new TabProxy(sender_, tracker_, tab_handle);
 102     tab->AddRef();
 103   }
 104
 105   // Since there is no scoped_refptr::attach.
 106   scoped_refptr<TabProxy> result;
 107   result.swap(&tab);
 108   return result;
 109 }
 110
 111 scoped_refptr<TabProxy> BrowserProxy::GetActiveTab() const {
 112   int active_tab_index;
 113   if (!GetActiveTabIndex(&active_tab_index))
 114     return NULL;
 115   return GetTab(active_tab_index);
 116 }
 117
 118 bool BrowserProxy::GetTabCount(int* num_tabs) const {
 119   if (!is_valid())
 120     return false;
 121
 122   if (!num_tabs) {
 123     NOTREACHED();
 124     return false;
 125   }
 126
 127   int tab_count_response = -1;
 128
 129   if (!sender_->Send(new AutomationMsg_TabCount(
 130                          handle_, &tab_count_response))) {
 131     return false;
 132   }
 133
 134   if (tab_count_response >= 0) {
 135     *num_tabs = tab_count_response;
 136     return true;
 137   }
 138
 139   return false;
 140 }
 141
 142 bool BrowserProxy::GetType(Browser::Type* type) const {
 143   if (!is_valid())
 144     return false;
 145
 146   if (!type) {
 147     NOTREACHED();
 148     return false;
 149   }
 150
 151   int type_as_int;
 152   if (!sender_->Send(new AutomationMsg_Type(handle_, &type_as_int)))
 153     return false;
 154
 155   *type = static_cast<Browser::Type>(type_as_int);
 156   return true;
 157 }
 158
 159 bool BrowserProxy::ApplyAccelerator(int id) {
 160   return RunCommandAsync(id);
 161 }
 162
 163 bool BrowserProxy::WaitForTabCountToBecome(int count) {
 164   bool success = false;
 165   if (!sender_->Send(new AutomationMsg_WaitForTabCountToBecome(
 166                          handle_, count, &success))) {
 167     return false;
 168   }
 169
 170   return success;
 171 }
 172
 173 bool BrowserProxy::WaitForTabToBecomeActive(int tab,
 174                                             base::TimeDelta wait_timeout) {
 175   const TimeTicks start = TimeTicks::Now();
 176   while (TimeTicks::Now() - start < wait_timeout) {
 177     base::PlatformThread::Sleep(
 178         base::TimeDelta::FromMilliseconds(automation::kSleepTime));
 179     int active_tab;
 180     if (GetActiveTabIndex(&active_tab) && active_tab == tab)
 181       return true;
 182   }
 183   // If we get here, the active tab hasn't changed.
 184   return false;
 185 }
 186
 187 bool BrowserProxy::IsFindWindowFullyVisible(bool* is_visible) {
 188   if (!is_valid())
 189     return false;
 190
 191   if (!is_visible) {
 192     NOTREACHED();
 193     return false;
 194   }
 195
 196   return sender_->Send(
 197       new AutomationMsg_FindWindowVisibility(handle_, is_visible));
 198 }
 199
 200 bool BrowserProxy::RunCommandAsync(int browser_command) const {
 201   if (!is_valid())
 202     return false;
 203
 204   bool result = false;
 205
 206   sender_->Send(new AutomationMsg_WindowExecuteCommandAsync(handle_,
 207                                                             browser_command,
 208                                                             &result));
 209
 210   return result;
 211 }
 212
 213 bool BrowserProxy::RunCommand(int browser_command) const {
 214   if (!is_valid())
 215     return false;
 216
 217   bool result = false;
 218
 219   sender_->Send(new AutomationMsg_WindowExecuteCommand(handle_,
 220                                                        browser_command,
 221                                                        &result));
 222
 223   return result;
 224 }
 225
 226 bool BrowserProxy::TerminateSession() {
 227   if (!is_valid())
 228     return false;
 229
 230   bool result = false;
 231
 232   sender_->Send(new AutomationMsg_TerminateSession(handle_, &result));
 233
 234   return result;
 235 }
 236
 237 scoped_refptr<WindowProxy> BrowserProxy::GetWindow() const {
 238   if (!is_valid())
 239     return NULL;
 240
 241   bool handle_ok = false;
 242   int window_handle = 0;
 243
 244   sender_->Send(new AutomationMsg_WindowForBrowser(handle_, &handle_ok,
 245                                                    &window_handle));
 246   if (!handle_ok)
 247     return NULL;
 248
 249   WindowProxy* window =
 250       static_cast<WindowProxy*>(tracker_->GetResource(window_handle));
 251   if (!window) {
 252     window = new WindowProxy(sender_, tracker_, window_handle);
 253     window->AddRef();
 254   }
 255
 256   // Since there is no scoped_refptr::attach.
 257   scoped_refptr<WindowProxy> result;
 258   result.swap(&window);
 259   return result;
 260 }
 261
 262 bool BrowserProxy::SendJSONRequest(const std::string& request,
 263                                    int timeout_ms,
 264                                    std::string* response) {
 265   if (!is_valid())
 266     return false;
 267
 268   bool result = false;
 269   if (!sender_->Send(
 270       new AutomationMsg_SendJSONRequestWithBrowserHandle(handle_,
 271                                                          request,
 272                                                          response,
 273                                                          &result),
 274                                                          timeout_ms))
 275     return false;
 276   return result;
 277 }
 278
 279 bool BrowserProxy::GetInitialLoadTimes(base::TimeDelta timeout,
 280                                        float* min_start_time,
 281                                        float* max_stop_time,
 282                                        std::vector<float>* stop_times) {
 283   std::string json_response;
 284   const char* kJSONCommand = "{\"command\": \"GetInitialLoadTimes\"}";
 285
 286   *max_stop_time = 0;
 287   *min_start_time = -1;
 288   if (!SendJSONRequest(
 289           kJSONCommand, timeout.InMilliseconds(), &json_response)) {
 290     // Older browser versions do not support GetInitialLoadTimes.
 291     // Fail gracefully and do not record them in this case.
 292     return false;
 293   }
 294   std::string error;
 295   scoped_ptr<Value> values(base::JSONReader::ReadAndReturnError(
 296       json_response, base::JSON_ALLOW_TRAILING_COMMAS, NULL, &error));
 297   if (!error.empty() || values->GetType() != Value::TYPE_DICTIONARY)
 298     return false;
 299
 300   DictionaryValue* values_dict = static_cast<DictionaryValue*>(values.get());
 301
 302   Value* tabs_value;
 303   if (!values_dict->Get("tabs", &tabs_value) ||
 304       tabs_value->GetType() != Value::TYPE_LIST)
 305     return false;
 306
 307   ListValue* tabs_list = static_cast<ListValue*>(tabs_value);
 308
 309   for (size_t i = 0; i < tabs_list->GetSize(); i++) {
 310     float stop_ms = 0;
 311     float start_ms = 0;
 312     Value* tab_value;
 313     DictionaryValue* tab_dict;
 314
 315     if (!tabs_list->Get(i, &tab_value) ||
 316         tab_value->GetType() != Value::TYPE_DICTIONARY)
 317       return false;
 318     tab_dict = static_cast<DictionaryValue*>(tab_value);
 319
 320     double temp;
 321     if (!tab_dict->GetDouble("load_start_ms", &temp))
 322       return false;
 323     start_ms = static_cast<float>(temp);
 324     // load_stop_ms can only be null if WaitForInitialLoads did not run.
 325     if (!tab_dict->GetDouble("load_stop_ms", &temp))
 326       return false;
 327     stop_ms = static_cast<float>(temp);
 328
 329     if (i == 0)
 330       *min_start_time = start_ms;
 331
 332     *min_start_time = std::min(start_ms, *min_start_time);
 333     *max_stop_time = std::max(stop_ms, *max_stop_time);
 334     stop_times->push_back(stop_ms);
 335   }
 336   std::sort(stop_times->begin(), stop_times->end());
 337   return true;
 338 }