[chromedriver] Implement SwitchToFrame command.

chrome/test/chromedriver/chrome_impl.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/test/chromedriver/chrome_impl.h"
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/process_util.h"
 #include "base/stringprintf.h"
 #include "base/threading/platform_thread.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "chrome/test/chromedriver/devtools_client_impl.h"
+#include "chrome/test/chromedriver/dom_tracker.h"
 #include "chrome/test/chromedriver/js.h"
 #include "chrome/test/chromedriver/net/net_util.h"
 #include "chrome/test/chromedriver/net/sync_websocket_impl.h"
 #include "chrome/test/chromedriver/net/url_request_context_getter.h"
 #include "chrome/test/chromedriver/status.h"
 #include "googleurl/src/gurl.h"
 
 namespace {
 
 Status FetchPagesInfo(URLRequestContextGetter* context_getter,
                       int port,
                       std::list<std::string>* debugger_urls) {
   std::string url = base::StringPrintf(
       "http://127.0.0.1:%d/json", port);
   std::string data;
   if (!FetchUrl(GURL(url), context_getter, &data))
     return Status(kChromeNotReachable);
   return internal::ParsePagesInfo(data, debugger_urls);
 }
 
+Status GetContextIdForFrame(DomTracker* tracker,
+                            const std::string& frame,
+                            int* context_id) {
+  if (frame.empty()) {
+    *context_id = 0;
+    return Status(kOk);
+  }
+  Status status = tracker->GetContextIdForFrame(frame, context_id);
+  if (status.IsError())
+    return status;
+  return Status(kOk);
+}
+
 }  // namespace
 
 ChromeImpl::ChromeImpl(base::ProcessHandle process,
                        URLRequestContextGetter* context_getter,
                        base::ScopedTempDir* user_data_dir,
                        int port,
                        const SyncWebSocketFactory& socket_factory)
     : process_(process),
       context_getter_(context_getter),
       port_(port),
-      socket_factory_(socket_factory) {
+      socket_factory_(socket_factory),
+      dom_tracker_(new DomTracker()) {
   if (user_data_dir->IsValid()) {
     CHECK(user_data_dir_.Set(user_data_dir->Take()));
   }
 }
 
 ChromeImpl::~ChromeImpl() {
   base::CloseProcessHandle(process_);
 }
 
 Status ChromeImpl::Init() {
   base::Time deadline = base::Time::Now() + base::TimeDelta::FromSeconds(20);
   std::list<std::string> debugger_urls;
   while (base::Time::Now() < deadline) {
     FetchPagesInfo(context_getter_, port_, &debugger_urls);
     if (debugger_urls.empty())
       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
     else
       break;
   }
   if (debugger_urls.empty())
     return Status(kUnknownError, "unable to discover open pages");
   client_.reset(new DevToolsClientImpl(
-      socket_factory_, debugger_urls.front(), NULL));
-  return Status(kOk);
+      socket_factory_, debugger_urls.front(), dom_tracker_.get()));
+
+  // Perform necessary configuration of the DevTools client.
+  // Fetch the root document node so that Inspector will push DOM node
+  // information to the client.
+  base::DictionaryValue params;
+  Status status = client_->SendCommand("DOM.getDocument", params);
+  if (status.IsError())
+    return status;
+  // Enable runtime events to allow tracking execution context creation.
+  return client_->SendCommand("Runtime.enable", params);
 }
 
 Status ChromeImpl::Load(const std::string& url) {
   base::DictionaryValue params;
   params.SetString("url", url);
   return client_->SendCommand("Page.navigate", params);
 }
 
-Status ChromeImpl::EvaluateScript(const std::string& expression,
+Status ChromeImpl::EvaluateScript(const std::string& frame,
+                                  const std::string& expression,
                                   scoped_ptr<base::Value>* result) {
-  return internal::EvaluateScript(client_.get(), expression, result);
+  int context_id;
+  Status status = GetContextIdForFrame(dom_tracker_.get(), frame, &context_id);
+  if (status.IsError())
+    return status;
+  return internal::EvaluateScriptAndGetValue(
+      client_.get(), context_id, expression, result);
 }
 
-Status ChromeImpl::CallFunction(const std::string& function,
+Status ChromeImpl::CallFunction(const std::string& frame,
+                                const std::string& function,
                                 const base::ListValue& args,
                                 scoped_ptr<base::Value>* result) {
   std::string json;
   base::JSONWriter::Write(&args, &json);
   std::string expression = base::StringPrintf(
       "(%s).apply(null, [%s, %s])",
       kCallFunctionScript,
       function.c_str(),
       json.c_str());
-  return EvaluateScript(expression, result);
+  return EvaluateScript(frame, expression, result);
+}
+
+Status ChromeImpl::GetFrameByFunction(const std::string& frame,
+                                      const std::string& function,
+                                      const base::ListValue& args,
+                                      std::string* out_frame) {
+  int context_id;
+  Status status = GetContextIdForFrame(dom_tracker_.get(), frame, &context_id);
+  if (status.IsError())
+    return status;
+  int node_id;
+  status = internal::GetNodeIdFromFunction(
+      client_.get(), context_id, function, args, &node_id);
+  if (status.IsError())
+    return status;
+  return dom_tracker_->GetFrameIdForNode(node_id, out_frame);
 }
 
 Status ChromeImpl::Quit() {
   if (!base::KillProcess(process_, 0, true))
     return Status(kUnknownError, "cannot kill Chrome");
   return Status(kOk);
 }
 
 namespace internal {
 
@@ skipping 14 matching lines @@
     std::string debugger_url;
     if (!info->GetString("webSocketDebuggerUrl", &debugger_url))
       return Status(kUnknownError, "DevTools did not include debugger URL");
     internal_urls.push_back(debugger_url);
   }
   debugger_urls->swap(internal_urls);
   return Status(kOk);
 }
 
 Status EvaluateScript(DevToolsClient* client,
+                      int context_id,
                       const std::string& expression,
-                      scoped_ptr<base::Value>* result) {
+                      EvaluateScriptReturnType return_type,
+                      scoped_ptr<base::DictionaryValue>* result) {
   base::DictionaryValue params;
   params.SetString("expression", expression);
-  params.SetBoolean("returnByValue", true);
+  if (context_id)
+    params.SetInteger("contextId", context_id);
+  params.SetBoolean("returnByValue", return_type == ReturnByValue);
   scoped_ptr<base::DictionaryValue> cmd_result;
   Status status = client->SendCommandAndGetResult(
       "Runtime.evaluate", params, &cmd_result);
   if (status.IsError())
     return status;
 
   bool was_thrown;
   if (!cmd_result->GetBoolean("wasThrown", &was_thrown))
     return Status(kUnknownError, "Runtime.evaluate missing 'wasThrown'");
   if (was_thrown) {
     std::string description = "unknown";
     cmd_result->GetString("result.description", &description);
     return Status(kUnknownError,
                   "Runtime.evaluate threw exception: " + description);
   }
 
+  base::DictionaryValue* unscoped_result;
+  if (!cmd_result->GetDictionary("result", &unscoped_result))
+    return Status(kUnknownError, "evaluate missing dictionary 'result'");
+  result->reset(unscoped_result->DeepCopy());
+  return Status(kOk);
+}
+
+Status EvaluateScriptAndGetObject(DevToolsClient* client,
+                                  int context_id,
+                                  const std::string& expression,
+                                  std::string* object_id) {
+  scoped_ptr<base::DictionaryValue> result;
+  Status status = EvaluateScript(client, context_id, expression, ReturnByObject,
+                                 &result);
+  if (status.IsError())
+    return status;
+  if (!result->GetString("objectId", object_id))
+    return Status(kUnknownError, "evaluate missing string 'objectId'");
+  return Status(kOk);
+}
+
+Status EvaluateScriptAndGetValue(DevToolsClient* client,
+                                 int context_id,
+                                 const std::string& expression,
+                                 scoped_ptr<base::Value>* result) {
+  scoped_ptr<base::DictionaryValue> temp_result;
+  Status status = EvaluateScript(client, context_id, expression, ReturnByValue,
+                                 &temp_result);
+  if (status.IsError())
+    return status;
+
   std::string type;
-  if (!cmd_result->GetString("result.type", &type))
-    return Status(kUnknownError, "Runtime.evaluate missing result.type");
+  if (!temp_result->GetString("type", &type))
+    return Status(kUnknownError, "Runtime.evaluate missing string 'type'");
 
   if (type == "undefined") {
     result->reset(base::Value::CreateNullValue());
   } else {
     int status_code;
-    if (!cmd_result->GetInteger("result.value.status", &status_code)) {
+    if (!temp_result->GetInteger("value.status", &status_code)) {
       return Status(kUnknownError,
-                    "Runtime.evaluate missing result.value.status");
+                    "Runtime.evaluate missing int 'value.status'");
     }
     if (status_code != kOk)
       return Status(static_cast<StatusCode>(status_code));
     base::Value* unscoped_value;
-    if (!cmd_result->Get("result.value.value", &unscoped_value)) {
+    if (!temp_result->Get("value.value", &unscoped_value)) {
       return Status(kUnknownError,
-                    "Runtime.evaluate missing result.value.value");
+                    "Runtime.evaluate missing 'value.value'");
     }
     result->reset(unscoped_value->DeepCopy());
   }
   return Status(kOk);
 }
 
+Status GetNodeIdFromFunction(DevToolsClient* client,
+                             int context_id,
+                             const std::string& function,
+                             const base::ListValue& args,
+                             int* node_id) {
+  std::string json;
+  base::JSONWriter::Write(&args, &json);
+  std::string expression = base::StringPrintf(
+      "(%s).apply(null, [%s, %s, true])",
+      kCallFunctionScript,
+      function.c_str(),
+      json.c_str());
+
+  std::string element_id;
+  Status status = internal::EvaluateScriptAndGetObject(
+      client, context_id, expression, &element_id);
+  if (status.IsError())
+    return status;
+
+  scoped_ptr<base::DictionaryValue> cmd_result;
+  {
+    base::DictionaryValue params;
+    params.SetString("objectId", element_id);
+    status = client->SendCommandAndGetResult(
+        "DOM.requestNode", params, &cmd_result);
+  }
+  {
+    // Release the remote object before doing anything else.
+    base::DictionaryValue params;
+    params.SetString("objectId", element_id);
+    Status release_status =
+        client->SendCommand("Runtime.releaseObject", params);
+    if (release_status.IsError()) {
+      LOG(ERROR) << "Failed to release remote object: "
+                 << release_status.message();
+    }
+  }
+  if (status.IsError())
+    return status;
+
+  if (!cmd_result->GetInteger("nodeId", node_id))
+    return Status(kUnknownError, "DOM.requestNode missing int 'nodeId'");
+  return Status(kOk);
+}
+
 }  // namespace internal