Introduce callback interface for running Javascript asynchronously in the renderer.

content/browser/renderer_host/render_view_host_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 "content/browser/renderer_host/render_view_host_impl.h"
 
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
+#include "base/callback.h"
+#include "base/command_line.h"
 #include "base/i18n/rtl.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
-#include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "content/browser/accessibility/browser_accessibility_state_impl.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/cross_site_request_manager.h"
@@ skipping 685 matching lines @@
 
 int RenderViewHostImpl::ExecuteJavascriptInWebFrameNotifyResult(
     const string16& frame_xpath,
     const string16& jscript) {
   static int next_id = 1;
   Send(new ViewMsg_ScriptEvalRequest(GetRoutingID(), frame_xpath, jscript,
                                      next_id, true));
   return next_id++;
 }
 
-typedef std::pair<int, Value*> ExecuteDetailType;
+void RenderViewHostImpl::ExecuteJavascriptInWebFrameCallbackResult(
+     const string16& frame_xpath,
+     const string16& jscript,
+     const JavascriptResultCallback& callback) {
+  int key = ExecuteJavascriptInWebFrameNotifyResult(frame_xpath, jscript);
+  javascript_callbacks_.insert(std::make_pair(key, callback));
+}
+
+typedef std::pair<int, base::Value*> ExecuteDetailType;
 
 ExecuteNotificationObserver::ExecuteNotificationObserver(int id)
 : id_(id) {
 }
 
 ExecuteNotificationObserver::~ExecuteNotificationObserver() {
 }
 
 void ExecuteNotificationObserver::Observe(int type,
                      const NotificationSource& source,
                      const NotificationDetails& details) {
   Details<ExecuteDetailType> execute_details =
       static_cast<Details<ExecuteDetailType> >(details);
   int id = execute_details->first;
   if (id != id_)
     return;
-  Value* value = execute_details->second;
+  base::Value* value = execute_details->second;
   if (value)
     value_.reset(value->DeepCopy());
   MessageLoop::current()->Quit();
 }
 
-Value* RenderViewHostImpl::ExecuteJavascriptAndGetValue(
+base::Value* RenderViewHostImpl::ExecuteJavascriptAndGetValue(
     const string16& frame_xpath,
     const string16& jscript) {
   int id = ExecuteJavascriptInWebFrameNotifyResult(frame_xpath, jscript);
   ExecuteNotificationObserver observer(id);
   NotificationRegistrar notification_registrar;
   notification_registrar.Add(
       &observer, NOTIFICATION_EXECUTE_JAVASCRIPT_RESULT,
       Source<RenderViewHost>(this));
   MessageLoop* loop = MessageLoop::current();
   loop->Run();
@@ skipping 1155 matching lines @@
       dst_type = NOTIFICATION_ACCESSIBILITY_OTHER;
     NotificationService::current()->Notify(
           dst_type,
           Source<RenderViewHost>(this),
           NotificationService::NoDetails());
   }
 
   Send(new AccessibilityMsg_Notifications_ACK(GetRoutingID()));
 }
 
-void RenderViewHostImpl::OnScriptEvalResponse(int id, const ListValue& result) {
-  const Value* result_value;
+void RenderViewHostImpl::OnScriptEvalResponse(int id,
+                                              const base::ListValue& result) {
+  const base::Value* result_value;
   if (!result.Get(0, &result_value)) {
     // Programming error or rogue renderer.
     NOTREACHED() << "Got bad arguments for OnScriptEvalResponse";
     return;
   }
-  std::pair<int, const Value*> details(id, result_value);
-  NotificationService::current()->Notify(
-      NOTIFICATION_EXECUTE_JAVASCRIPT_RESULT,
-      Source<RenderViewHost>(this),
-      Details<std::pair<int, const Value*> >(&details));
+
+  std::map<int, JavascriptResultCallback>::iterator it =
+      javascript_callbacks_.find(id);
+  if (it != javascript_callbacks_.end()) {
+    // ExecuteJavascriptInWebFrameCallbackResult was used; do callback.
+    it->second.Run(result_value);
+    javascript_callbacks_.erase(it);
+  } else {
+    // ExecuteJavascriptInWebFrameNotifyResult was used; broadcast result.
+    std::pair<int, const base::Value*> details(id, result_value);
+    NotificationService::current()->Notify(
+        NOTIFICATION_EXECUTE_JAVASCRIPT_RESULT,
+        Source<RenderViewHost>(this),
+        Details<std::pair<int, const base::Value*> >(&details));
+  }
 }
 
 void RenderViewHostImpl::OnDidZoomURL(double zoom_level,
                                       bool remember,
                                       const GURL& url) {
   HostZoomMapImpl* host_zoom_map = static_cast<HostZoomMapImpl*>(
       HostZoomMap::GetForBrowserContext(GetProcess()->GetBrowserContext()));
   if (remember) {
     host_zoom_map->SetZoomLevel(net::GetHostOrSpecFromURL(url), zoom_level);
   } else {
@@ skipping 132 matching lines @@
           GetRoutingID(), snapshot_id, snapshot_size, png));
       return;
     }
   }
 
   Send(new ViewMsg_WindowSnapshotCompleted(
       GetRoutingID(), snapshot_id, gfx::Size(), png));
 }
 
 }  // namespace content