Pass RenderFrameHost to WebContentObservers' message handlers

content/browser/renderer_host/java/java_bridge_dispatcher_host_manager.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/java/java_bridge_dispatcher_host_manager.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_weak_ref.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/renderer_host/java/java_bound_object.h"
 #include "content/browser/renderer_host/java/java_bridge_dispatcher_host.h"
 #include "content/common/android/hash_set.h"
+#include "content/common/java_bridge_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "third_party/WebKit/public/web/WebBindings.h"
 
 namespace content {
 
 JavaBridgeDispatcherHostManager::JavaBridgeDispatcherHostManager(
-    WebContents* web_contents)
+    WebContents* web_contents,
+    jobject retained_object_set)
     : WebContentsObserver(web_contents),
+      retained_object_set_(base::android::AttachCurrentThread(),
+                           retained_object_set),
       allow_object_contents_inspection_(true) {
+  DCHECK(retained_object_set);

[benm (inactive), 2014/05/07 13:51:43]

should this be retained_object_set_ (i.e. the member, not the parameter?)

[mnaganov (inactive), 2014/05/07 15:12:35]

Here we are checking that we have received an actual object, not a Null. And the
member is JavaObjectWeakGlobalRef, thus it's a "processed" argument, and it can
be null for some other reason.

 }
 
 JavaBridgeDispatcherHostManager::~JavaBridgeDispatcherHostManager() {
   for (ObjectMap::iterator iter = objects_.begin(); iter != objects_.end();
       ++iter) {
     blink::WebBindings::releaseObject(iter->second);
   }
   DCHECK_EQ(0U, instances_.size());
 }
 
 void JavaBridgeDispatcherHostManager::AddNamedObject(const base::string16& name,
                                                      NPObject* object) {
   // Record this object in a map so that we can add it into RenderViewHosts
   // created later. The JavaBridgeDispatcherHost instances will take a
   // reference to the object, but we take one too, because this method can be
   // called before there are any such instances.
   blink::WebBindings::retainObject(object);
   objects_[name] = object;
 
   for (InstanceMap::iterator iter = instances_.begin();
       iter != instances_.end(); ++iter) {
     iter->second->AddNamedObject(name, object);
   }
 }
 
-void JavaBridgeDispatcherHostManager::SetRetainedObjectSet(
-    const JavaObjectWeakGlobalRef& retained_object_set) {
-  // It's an error to replace the retained_object_set_ after it's been set,
-  // so we check that it hasn't already been here.
-  // TODO(benm): It'd be better to pass the set in the constructor to avoid
-  // the chance of this happening; but that's tricky as this get's constructed
-  // before ContentViewCore (which owns the set). Best solution may be to move
-  // ownership of the JavaBridgerDispatchHostManager from WebContents to
-  // ContentViewCore?
-  JNIEnv* env = base::android::AttachCurrentThread();
-  base::android::ScopedJavaLocalRef<jobject> new_retained_object_set =
-      retained_object_set.get(env);
-  base::android::ScopedJavaLocalRef<jobject> current_retained_object_set =
-      retained_object_set_.get(env);
-  if (!env->IsSameObject(new_retained_object_set.obj(),
-                         current_retained_object_set.obj())) {
-    DCHECK(current_retained_object_set.is_null());
-    retained_object_set_ = retained_object_set;
-  }
-}
-
 void JavaBridgeDispatcherHostManager::RemoveNamedObject(
     const base::string16& name) {
   ObjectMap::iterator iter = objects_.find(name);
   if (iter == objects_.end()) {
     return;
   }
 
   blink::WebBindings::releaseObject(iter->second);
   objects_.erase(iter);
 
   for (InstanceMap::iterator iter = instances_.begin();
       iter != instances_.end(); ++iter) {
     iter->second->RemoveNamedObject(name);
   }
 }
 
-void JavaBridgeDispatcherHostManager::OnGetChannelHandle(
-    RenderFrameHost* render_frame_host, IPC::Message* reply_msg) {
-  instances_[render_frame_host]->OnGetChannelHandle(reply_msg);
-}
-
 void JavaBridgeDispatcherHostManager::RenderFrameCreated(
     RenderFrameHost* render_frame_host) {
   // Creates a JavaBridgeDispatcherHost for the specified RenderViewHost and
   // adds all currently registered named objects to the new instance.
   scoped_refptr<JavaBridgeDispatcherHost> instance =
       new JavaBridgeDispatcherHost(render_frame_host);
 
   for (ObjectMap::const_iterator iter = objects_.begin();
       iter != objects_.end(); ++iter) {
     instance->AddNamedObject(iter->first, iter->second);
@@ skipping 22 matching lines @@
     // We also need to add back the named objects we have so far as they
     // should survive navigations.
     ObjectMap::iterator it = objects_.begin();
     for (; it != objects_.end(); ++it) {
       JNI_Java_HashSet_add(env, retained_object_set,
                            JavaBoundObject::GetJavaObject(it->second));
     }
   }
 }
 
+bool JavaBridgeDispatcherHostManager::OnMessageReceived(
+    const IPC::Message& message,
+    RenderFrameHost* render_frame_host) {
+  DCHECK(render_frame_host);
+  scoped_refptr<JavaBridgeDispatcherHost> instance =
+      instances_[render_frame_host];
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(JavaBridgeDispatcherHostManager, message)
+    IPC_MESSAGE_FORWARD_DELAY_REPLY(
+        JavaBridgeHostMsg_GetChannelHandle,
+        instance.get(),
+        JavaBridgeDispatcherHost::OnGetChannelHandle)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
 void JavaBridgeDispatcherHostManager::JavaBoundObjectCreated(
     const base::android::JavaRef<jobject>& object) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   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_add(env, retained_object_set, object);
   }
@@ skipping 10 matching lines @@
     JNI_Java_HashSet_remove(env, retained_object_set, object);
   }
 }
 
 void JavaBridgeDispatcherHostManager::SetAllowObjectContentsInspection(
     bool allow) {
   allow_object_contents_inspection_ = allow;
 }
 
 }  // namespace content