Expose distiller functions to JavaScript

content/public/test/browser_test_utils.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 "content/public/test/browser_test_utils.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
@@ skipping 145 matching lines @@
   base::JSONReader reader(base::JSON_ALLOW_TRAILING_COMMAS);
   *result = reader.ReadToValue(json);
   if (!*result) {
     DLOG(ERROR) << reader.GetErrorMessage();
     return false;
   }
 
   return true;
 }
 
+// Specifying a prototype so that we can add the WARN_UNUSED_RESULT attribute.
+bool ExecuteScriptInIsolatedWorldHelper(RenderFrameHost* render_frame_host,
+                                        const int world_id,
+                                        const std::string& original_script,
+                                        scoped_ptr<base::Value>* result)
+    WARN_UNUSED_RESULT;

[nasko, 2015/09/02 21:59:40]

Why not just add this on the method itself? Why do we need a prototype?

[mdjones, 2015/09/03 01:38:29]

The compiler throws an error if that attribute is put on the method (though I
see it is used like this in other places outside this file). This follows the
pattern that "ExecuteScriptHelper" uses.

+
+bool ExecuteScriptInIsolatedWorldHelper(RenderFrameHost* render_frame_host,
+                                        const int world_id,
+                                        const std::string& original_script,
+                                        scoped_ptr<base::Value>* result) {
+  std::string script =
+      "window.domAutomationController.setAutomationId(0);" + original_script;
+  DOMOperationObserver dom_op_observer(render_frame_host->GetRenderViewHost());
+  render_frame_host->ExecuteJavaScriptInIsolatedWorld(
+      base::UTF8ToUTF16(script),
+      content::RenderFrameHost::JavaScriptResultCallback(), world_id);
+  std::string json;
+  if (!dom_op_observer.WaitAndGetResponse(&json)) {
+    DLOG(ERROR) << "Cannot communicate with DOMOperationObserver.";
+    return false;
+  }
+
+  // Nothing more to do for callers that ignore the returned JS value.
+  if (!result)
+    return true;
+
+  base::JSONReader reader(base::JSON_ALLOW_TRAILING_COMMAS);
+  *result = reader.ReadToValue(json);
+  if (!*result) {
+    DLOG(ERROR) << reader.GetErrorMessage();
+    return false;
+  }
+
+  return true;
+}
+
 void BuildSimpleWebKeyEvent(blink::WebInputEvent::Type type,
                             ui::KeyboardCode key_code,
                             int native_key_code,
                             int modifiers,
                             NativeWebKeyboardEvent* event) {
   event->nativeKeyCode = native_key_code;
   event->windowsKeyCode = key_code;
   event->setKeyIdentifierFromWindowsKeyCode();
   event->type = type;
   event->modifiers = modifiers;
@@ skipping 402 matching lines @@
   DCHECK(result);
   scoped_ptr<base::Value> value;
   if (!ExecuteScriptHelper(adapter.render_frame_host(), script, &value) ||
       !value.get()) {
     return false;
   }
 
   return value->GetAsBoolean(result);
 }
 
+bool ExecuteScriptInIsolatedWorldAndExtractBool(
+    const ToRenderFrameHost& adapter,
+    const int world_id,
+    const std::string& script,
+    bool* result) {
+  DCHECK(result);
+  scoped_ptr<base::Value> value;
+  if (!ExecuteScriptInIsolatedWorldHelper(adapter.render_frame_host(), world_id,
+                                          script, &value) ||
+      !value.get()) {
+    return false;
+  }
+
+  return value->GetAsBoolean(result);
+}
+
 bool ExecuteScriptAndExtractString(const ToRenderFrameHost& adapter,
                                    const std::string& script,
                                    std::string* result) {
   DCHECK(result);
   scoped_ptr<base::Value> value;
   if (!ExecuteScriptHelper(adapter.render_frame_host(), script, &value) ||
       !value.get()) {
     return false;
   }
 
@@ skipping 389 matching lines @@
 void FrameWatcher::WaitFrames(int frames_to_wait) {
   if (frames_to_wait <= 0)
     return;
   base::RunLoop run_loop;
   base::AutoReset<base::Closure> reset_quit(&quit_, run_loop.QuitClosure());
   base::AutoReset<int> reset_frames_to_wait(&frames_to_wait_, frames_to_wait);
   run_loop.Run();
 }
 
 }  // namespace content