Create a public API around webkit::ppapi::PluginInstance and use it in chrome. After this, webkit/p…

webkit/plugins/ppapi/host_globals.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 "webkit/plugins/ppapi/host_globals.h"
 
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task_runner.h"
 #include "ppapi/shared_impl/api_id.h"
 #include "ppapi/shared_impl/id_assignment.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/web/WebConsoleMessage.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebPluginContainer.h"
 #include "webkit/plugins/plugin_switches.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
-#include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
+#include "webkit/plugins/ppapi/ppapi_plugin_instance_impl.h"
 
 using ppapi::CheckIdType;
 using ppapi::MakeTypedId;
 using ppapi::PPIdType;
 using ppapi::ResourceTracker;
 using WebKit::WebConsoleMessage;
 using WebKit::WebString;
 
 namespace webkit {
 namespace ppapi {
@@ skipping 77 matching lines @@
 }
 
 ::ppapi::thunk::PPB_Instance_API* HostGlobals::GetInstanceAPI(
     PP_Instance instance) {
   // The InstanceAPI is just implemented by the PluginInstance object.
   return GetInstance(instance);
 }
 
 ::ppapi::thunk::ResourceCreationAPI* HostGlobals::GetResourceCreationAPI(
     PP_Instance pp_instance) {
-  PluginInstance* instance = GetInstance(pp_instance);
+  PluginInstanceImpl* instance = GetInstance(pp_instance);
   if (!instance)
     return NULL;
   return &instance->resource_creation();
 }
 
 PP_Module HostGlobals::GetModuleForInstance(PP_Instance instance) {
-  PluginInstance* inst = GetInstance(instance);
+  PluginInstanceImpl* inst = GetInstance(instance);
   if (!inst)
     return 0;
   return inst->module()->pp_module();
 }
 
 std::string HostGlobals::GetCmdLine() {
   return CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
       switches::kPpapiFlashArgs);
 }
 
 void HostGlobals::PreCacheFontForFlash(const void* logfontw) {
   // Not implemented in-process.
 }
 
 base::Lock* HostGlobals::GetProxyLock() {
   // We do not lock on the host side.
   return NULL;
 }
 
 void HostGlobals::LogWithSource(PP_Instance instance,
                                 PP_LogLevel level,
                                 const std::string& source,
                                 const std::string& value) {
-  PluginInstance* instance_object = HostGlobals::Get()->GetInstance(instance);
+  PluginInstanceImpl* instance_object =
+      HostGlobals::Get()->GetInstance(instance);
   if (instance_object) {
     instance_object->container()->element().document().frame()->
         addMessageToConsole(MakeLogMessage(level, source, value));
   } else {
     BroadcastLogWithSource(0, level, source, value);
   }
 }
 
 void HostGlobals::BroadcastLogWithSource(PP_Module pp_module,
                                          PP_LogLevel level,
@@ skipping 14 matching lines @@
     }
   }
 
   WebConsoleMessage message = MakeLogMessage(level, source, value);
   for (ContainerSet::iterator i = containers.begin();
        i != containers.end(); ++i)
      (*i)->element().document().frame()->addMessageToConsole(message);
 }
 
 base::TaskRunner* HostGlobals::GetFileTaskRunner(PP_Instance instance) {
-  scoped_refptr<PluginInstance> plugin_instance = GetInstance(instance);
+  scoped_refptr<PluginInstanceImpl> plugin_instance = GetInstance(instance);
   DCHECK(plugin_instance.get());
   scoped_refptr<base::MessageLoopProxy> message_loop =
       plugin_instance->delegate()->GetFileThreadMessageLoopProxy();
   return message_loop.get();
 }
 
 ::ppapi::MessageLoopShared* HostGlobals::GetCurrentMessageLoop() {
   return NULL;
 }
 
@@ skipping 29 matching lines @@
 
 PluginModule* HostGlobals::GetModule(PP_Module module) {
   DLOG_IF(ERROR, !CheckIdType(module, ::ppapi::PP_ID_TYPE_MODULE))
       << module << " is not a PP_Module.";
   ModuleMap::iterator found = module_map_.find(module);
   if (found == module_map_.end())
     return NULL;
   return found->second;
 }
 
-PP_Instance HostGlobals::AddInstance(PluginInstance* instance) {
+PP_Instance HostGlobals::AddInstance(PluginInstanceImpl* instance) {
   DCHECK(instance_map_.find(instance->pp_instance()) == instance_map_.end());
 
   // Use a random number for the instance ID. This helps prevent some
   // accidents. See also AddModule below.
   //
   // Need to make sure the random number isn't a duplicate or 0.
   PP_Instance new_instance;
   do {
     new_instance = MakeTypedId(static_cast<PP_Instance>(base::RandUint64()),
                                ::ppapi::PP_ID_TYPE_INSTANCE);
@@ skipping 11 matching lines @@
   resource_tracker_.DidDeleteInstance(instance);
   host_var_tracker_.DidDeleteInstance(instance);
   instance_map_.erase(instance);
 }
 
 void HostGlobals::InstanceCrashed(PP_Instance instance) {
   resource_tracker_.DidDeleteInstance(instance);
   host_var_tracker_.DidDeleteInstance(instance);
 }
 
-PluginInstance* HostGlobals::GetInstance(PP_Instance instance) {
+PluginInstanceImpl* HostGlobals::GetInstance(PP_Instance instance) {
   DLOG_IF(ERROR, !CheckIdType(instance, ::ppapi::PP_ID_TYPE_INSTANCE))
       << instance << " is not a PP_Instance.";
   InstanceMap::iterator found = instance_map_.find(instance);
   if (found == instance_map_.end())
     return NULL;
   return found->second;
 }
 
 bool HostGlobals::IsHostGlobals() const {
   return true;
 }
 
 }  // namespace ppapi
 }  // namespace webkit