BrowserPlugin: Simplify content/public API

content/browser/browser_plugin/browser_plugin_guest_manager.cc

 // Copyright (c) 2013 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/browser_plugin/browser_plugin_guest_manager.h"
 
 #include "content/browser/browser_plugin/browser_plugin_guest.h"
 #include "content/browser/browser_plugin/browser_plugin_host_factory.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
@@ skipping 103 matching lines @@
         embedder_site_instance->GetBrowserContext(), guest_site);
   }
 
   return WebContentsImpl::CreateGuest(
       embedder_site_instance->GetBrowserContext(),
       guest_site_instance,
       instance_id,
       extra_params.Pass());
 }
 
-BrowserPluginGuest* BrowserPluginGuestManager::GetGuestByInstanceID(
+static void BrowserPluginGuestByInstanceIDCallback(
+    const BrowserPluginGuestManager::GuestByInstanceIDCallback& callback,
+    WebContents* guest_web_contents) {
+  if (!guest_web_contents) {
+    callback.Run(NULL);
+    return;
+  }
+  callback.Run(static_cast<WebContentsImpl*>(guest_web_contents)->
+                   GetBrowserPluginGuest());
+}
+
+void BrowserPluginGuestManager::MaybeGetGuestByInstanceIDOrKill(
     int instance_id,
-    int embedder_render_process_id) const {
-  if (!GetDelegate())
-    return NULL;
+    int embedder_render_process_id,
+    const GuestByInstanceIDCallback& callback) const {
+  if (!GetDelegate()) {
+    callback.Run(NULL);
+    return;
+  }
 
-  WebContentsImpl* guest_web_contents = static_cast<WebContentsImpl*>(
-      GetDelegate()->GetGuestByInstanceID(instance_id,
-                                          embedder_render_process_id));
-
-  return guest_web_contents ?
-      guest_web_contents->GetBrowserPluginGuest() : NULL;
+  GetDelegate()->MaybeGetGuestByInstanceIDOrKill(
+      instance_id,
+      embedder_render_process_id,
+      base::Bind(&BrowserPluginGuestByInstanceIDCallback,
+                 callback));
 }
 
 void BrowserPluginGuestManager::AddGuest(int instance_id,
                                          WebContents* guest_web_contents) {
   if (!GetDelegate())
     return;
   GetDelegate()->AddGuest(instance_id, guest_web_contents);
 }
 
 void BrowserPluginGuestManager::RemoveGuest(int instance_id) {
   if (!GetDelegate())
     return;
   GetDelegate()->RemoveGuest(instance_id);
 }
 
-bool BrowserPluginGuestManager::CanEmbedderAccessInstanceIDMaybeKill(
-    int embedder_render_process_id,
-    int instance_id) const {
-  if (!GetDelegate())
-    return false;
-
-  return GetDelegate()->CanEmbedderAccessInstanceIDMaybeKill(
-      embedder_render_process_id, instance_id);
+static void BrowserPluginGuestMessageCallback(const IPC::Message& message,
+                                              BrowserPluginGuest* guest) {
+  if (!guest)
+    return;
+  guest->OnMessageReceivedFromEmbedder(message);
 }
 
 void BrowserPluginGuestManager::OnMessageReceived(const IPC::Message& message,
                                                   int render_process_id) {
   DCHECK(BrowserPluginGuest::ShouldForwardToBrowserPluginGuest(message));
   int instance_id = 0;
   // All allowed messages must have instance_id as their first parameter.
   PickleIterator iter(message);
   bool success = iter.ReadInt(&instance_id);
   DCHECK(success);
-  BrowserPluginGuest* guest =
-      GetGuestByInstanceID(instance_id, render_process_id);
-  if (!guest)
-    return;
-  guest->OnMessageReceivedFromEmbedder(message);
+  MaybeGetGuestByInstanceIDOrKill(instance_id,
+                                  render_process_id,
+                                  base::Bind(&BrowserPluginGuestMessageCallback,
+                                             message));
 }
 
 SiteInstance* BrowserPluginGuestManager::GetGuestSiteInstance(
     const GURL& guest_site) {
   if (!GetDelegate())
     return NULL;
   return GetDelegate()->GetGuestSiteInstance(guest_site);
 }
 
 static bool BrowserPluginGuestCallback(
     const BrowserPluginGuestManager::GuestCallback& callback,
     WebContents* guest_web_contents) {
   return callback.Run(static_cast<WebContentsImpl*>(guest_web_contents)
                           ->GetBrowserPluginGuest());
 }
 
 bool BrowserPluginGuestManager::ForEachGuest(
     WebContents* embedder_web_contents, const GuestCallback& callback) {
   if (!GetDelegate())
     return false;
   return GetDelegate()->ForEachGuest(embedder_web_contents,
                                      base::Bind(&BrowserPluginGuestCallback,
                                                 callback));
 }
 
 }  // namespace content