[Android] Switch to Gin Java Bridge implementation

content/browser/android/java/gin_java_bridge_dispatcher_host.cc

 // Copyright 2014 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/android/java/gin_java_bridge_dispatcher_host.h"
 
 #include "base/android/java_handler_thread.h"
 #include "base/android/jni_android.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/lazy_instance.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task_runner_util.h"
 #include "content/browser/android/java/gin_java_bound_object_delegate.h"
 #include "content/browser/android/java/jni_helper.h"
 #include "content/common/android/gin_java_bridge_value.h"
 #include "content/common/android/hash_set.h"
 #include "content/common/gin_java_bridge_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/web_contents.h"
 #include "ipc/ipc_message_utils.h"
 
 #if !defined(OS_ANDROID)
 #error "JavaBridge only supports OS_ANDROID"
 #endif
 
 namespace content {
 
 namespace {
 // The JavaBridge needs to use a Java thread so the callback
@@ skipping 21 matching lines @@
                            retained_object_set),
       allow_object_contents_inspection_(true) {
   DCHECK(retained_object_set);
 }
 
 GinJavaBridgeDispatcherHost::~GinJavaBridgeDispatcherHost() {
 }
 
 void GinJavaBridgeDispatcherHost::RenderFrameCreated(
     RenderFrameHost* render_frame_host) {
-  renderers_.insert(render_frame_host);
   for (NamedObjectMap::const_iterator iter = named_objects_.begin();
        iter != named_objects_.end();
        ++iter) {
     render_frame_host->Send(new GinJavaBridgeMsg_AddNamedObject(
         render_frame_host->GetRoutingID(), iter->first, iter->second));
   }
 }
 
 void GinJavaBridgeDispatcherHost::RenderFrameDeleted(
     RenderFrameHost* render_frame_host) {
-  renderers_.erase(render_frame_host);
   RemoveHolder(render_frame_host,
                GinJavaBoundObject::ObjectMap::iterator(&objects_),
                objects_.size());
 }
 
 GinJavaBoundObject::ObjectID GinJavaBridgeDispatcherHost::AddObject(
     const base::android::JavaRef<jobject>& object,
     const base::android::JavaRef<jclass>& safe_annotation_clazz,
     bool is_named,
     RenderFrameHost* holder) {
@@ skipping 91 matching lines @@
   if (iter != named_objects_.end()) {
     RemoveNamedObject(iter->first);
   }
   if (existing_object) {
     (*objects_.Lookup(object_id))->AddName();
   } else {
     object_id = AddObject(object, safe_annotation_clazz, true, NULL);
   }
   named_objects_[name] = object_id;
 
-  for (RendererSet::iterator iter = renderers_.begin();
-      iter != renderers_.end(); ++iter) {
-    (*iter)->Send(new GinJavaBridgeMsg_AddNamedObject(
-        (*iter)->GetRoutingID(), name, object_id));
-  }
+  web_contents()->SendToAllFrames(
+      new GinJavaBridgeMsg_AddNamedObject(MSG_ROUTING_NONE, name, object_id));
 }
 
 void GinJavaBridgeDispatcherHost::RemoveNamedObject(
     const std::string& name) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   NamedObjectMap::iterator iter = named_objects_.find(name);
   if (iter == named_objects_.end())
     return;
 
   scoped_refptr<GinJavaBoundObject> object(*objects_.Lookup(iter->second));
   named_objects_.erase(iter);
   object->RemoveName();
 
   // Not erasing from the objects map, as we can still receive method
   // invocation requests for this object, and they should work until the
   // java object is gone.
   if (!object->IsNamed()) {
     JNIEnv* env = base::android::AttachCurrentThread();
     base::android::ScopedJavaLocalRef<jobject> retained_object_set =
         retained_object_set_.get(env);
     if (!retained_object_set.is_null()) {
       JNI_Java_HashSet_remove(
           env, retained_object_set, object->GetLocalRef(env));
     }
   }
 
-  for (RendererSet::iterator iter = renderers_.begin();
-      iter != renderers_.end(); ++iter) {
-    (*iter)->Send(new GinJavaBridgeMsg_RemoveNamedObject(
-        (*iter)->GetRoutingID(), name));
-  }
+  web_contents()->SendToAllFrames(
+      new GinJavaBridgeMsg_RemoveNamedObject(MSG_ROUTING_NONE, name));
 }
 
 void GinJavaBridgeDispatcherHost::SetAllowObjectContentsInspection(bool allow) {
   allow_object_contents_inspection_ = allow;
 }
 
 void GinJavaBridgeDispatcherHost::DocumentAvailableInMainFrame() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Called when the window object has been cleared in the main frame.
   // That means, all sub-frames have also been cleared, so only named
@@ skipping 81 matching lines @@
     IPC_MESSAGE_FORWARD_DELAY_REPLY(GinJavaBridgeHostMsg_InvokeMethod,
                                     &forwarder,
                                     MessageForwarder::OnInvokeMethod)
     IPC_MESSAGE_HANDLER(GinJavaBridgeHostMsg_ObjectWrapperDeleted,
                         OnObjectWrapperDeleted)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
+namespace {
+
+class IsValidRenderFrameHostHelper
+    : public base::RefCounted<IsValidRenderFrameHostHelper> {
+ public:
+  explicit IsValidRenderFrameHostHelper(RenderFrameHost* rfh_to_match)
+      : rfh_to_match_(rfh_to_match), rfh_found_(false) {}
+
+  bool rfh_found() { return rfh_found_; }
+
+  void OnFrame(RenderFrameHost* rfh) {
+    if (rfh_to_match_ == rfh) rfh_found_ = true;
+  }
+
+ private:
+  friend class base::RefCounted<IsValidRenderFrameHostHelper>;
+
+  ~IsValidRenderFrameHostHelper() {}
+
+  RenderFrameHost* rfh_to_match_;
+  bool rfh_found_;
+
+  DISALLOW_COPY_AND_ASSIGN(IsValidRenderFrameHostHelper);
+};
+
+}  // namespace
+
+bool GinJavaBridgeDispatcherHost::IsValidRenderFrameHost(
+    RenderFrameHost* render_frame_host) {
+  scoped_refptr<IsValidRenderFrameHostHelper> helper =
+      new IsValidRenderFrameHostHelper(render_frame_host);
+  web_contents()->ForEachFrame(
+      base::Bind(&IsValidRenderFrameHostHelper::OnFrame, helper));
+  return helper->rfh_found();
+}
+
 void GinJavaBridgeDispatcherHost::SendReply(
     RenderFrameHost* render_frame_host,
     IPC::Message* reply_msg) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (renderers_.find(render_frame_host) != renderers_.end()) {
+  if (IsValidRenderFrameHost(render_frame_host)) {
     render_frame_host->Send(reply_msg);
   } else {
     delete reply_msg;
   }
 }
 
 void GinJavaBridgeDispatcherHost::OnGetMethods(
     RenderFrameHost* render_frame_host,
     GinJavaBoundObject::ObjectID object_id,
     IPC::Message* reply_msg) {
@@ skipping 111 matching lines @@
   } else {
     ProcessMethodInvocationObjectResult(render_frame_host, reply_msg, result);
   }
 }
 
 void GinJavaBridgeDispatcherHost::ProcessMethodInvocationObjectResult(
     RenderFrameHost* render_frame_host,
     IPC::Message* reply_msg,
     scoped_refptr<GinJavaMethodInvocationHelper> result) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (renderers_.find(render_frame_host) == renderers_.end()) {
+  if (!IsValidRenderFrameHost(render_frame_host)) {
     delete reply_msg;
     return;
   }
   base::ListValue wrapped_result;
   if (!result->GetObjectResult().is_null()) {
     GinJavaBoundObject::ObjectID returned_object_id;
     if (FindObjectId(result->GetObjectResult(), &returned_object_id)) {
       (*objects_.Lookup(returned_object_id))->AddHolder(render_frame_host);
     } else {
       returned_object_id = AddObject(result->GetObjectResult(),
@@ skipping 19 matching lines @@
   if (objects_.Lookup(object_id)) {
     GinJavaBoundObject::ObjectMap::iterator iter(&objects_);
     while (!iter.IsAtEnd() && iter.GetCurrentKey() != object_id)
       iter.Advance();
     DCHECK(!iter.IsAtEnd());
     RemoveHolder(render_frame_host, iter, 1);
   }
 }
 
 }  // namespace content