Support getting the font list in Pepper. This currently only works out of

ppapi/proxy/plugin_dispatcher.cc

 // Copyright (c) 2011 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 "ppapi/proxy/plugin_dispatcher.h"
 
 #include <map>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_sync_channel.h"
 #include "base/debug/trace_event.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/proxy/interface_proxy.h"
 #include "ppapi/proxy/plugin_message_filter.h"
 #include "ppapi/proxy/plugin_resource_tracker.h"
 #include "ppapi/proxy/plugin_var_serialization_rules.h"
 #include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/proxy/ppb_font_proxy.h"
 #include "ppapi/proxy/ppp_class_proxy.h"
 #include "ppapi/proxy/resource_creation_proxy.h"
 #include "ppapi/shared_impl/tracker_base.h"
 
 #if defined(OS_POSIX)
 #include "base/eintr_wrapper.h"
 #include "ipc/ipc_channel_posix.h"
 #endif
 
 namespace pp {
 namespace proxy {
 
 namespace {
 
 typedef std::map<PP_Instance, PluginDispatcher*> InstanceToDispatcherMap;
 InstanceToDispatcherMap* g_instance_to_dispatcher = NULL;
 
 }  // namespace
 
 PluginDispatcher::PluginDispatcher(base::ProcessHandle remote_process_handle,
                                    GetInterfaceFunc get_interface)
-    : Dispatcher(remote_process_handle, get_interface) {
+    : Dispatcher(remote_process_handle, get_interface),
+      plugin_delegate_(NULL) {
   SetSerializationRules(new PluginVarSerializationRules);
 
   // As a plugin, we always support the PPP_Class interface. There's no
   // GetInterface call or name for it, so we insert it into our table now.
   target_proxies_[INTERFACE_ID_PPP_CLASS].reset(new PPP_Class_Proxy(this));
 
   ::ppapi::TrackerBase::Init(
       &PluginResourceTracker::GetTrackerBaseInstance);
 }
 
@@ skipping 15 matching lines @@
 const void* PluginDispatcher::GetInterfaceFromDispatcher(
     const char* interface) {
   // All interfaces the plugin requests of the browser are "PPB".
   const InterfaceProxy::Info* info = GetPPBInterfaceInfo(interface);
   if (!info)
     return NULL;
   return info->interface_ptr;
 }
 
 bool PluginDispatcher::InitPluginWithChannel(
-    PluginDispatcher::Delegate* delegate,
+    PluginDelegate* delegate,
     const IPC::ChannelHandle& channel_handle,
     bool is_client) {
   if (!Dispatcher::InitWithChannel(delegate, channel_handle, is_client))
     return false;
-  SetDelegate(delegate);
+  plugin_delegate_ = delegate;
 
   // The message filter will intercept and process certain messages directly
   // on the I/O thread.
   channel()->AddFilter(
       new PluginMessageFilter(delegate->GetGloballySeenInstanceIDSet()));
   return true;
 }
 
 bool PluginDispatcher::IsPlugin() const {
   return true;
@@ skipping 105 matching lines @@
 }
 
 InstanceData* PluginDispatcher::GetInstanceData(PP_Instance instance) {
   InstanceDataMap::iterator it = instance_map_.find(instance);
   return (it == instance_map_.end()) ? NULL : &it->second;
 }
 
 void PluginDispatcher::PostToWebKitThread(
     const tracked_objects::Location& from_here,
     const base::Closure& task) {
-  return dispatcher_delegate_->PostToWebKitThread(from_here, task);
+  return plugin_delegate_->PostToWebKitThread(from_here, task);
+}
+
+bool PluginDispatcher::SendToBrowser(IPC::Message* msg) {
+  return plugin_delegate_->SendToBrowser(msg);
 }
 
 ppapi::WebKitForwarding* PluginDispatcher::GetWebKitForwarding() {
-  return dispatcher_delegate_->GetWebKitForwarding();
+  return plugin_delegate_->GetWebKitForwarding();
 }
 
 ::ppapi::FunctionGroupBase* PluginDispatcher::GetFunctionAPI(
     pp::proxy::InterfaceID id) {
   if (function_proxies_[id].get())
     return function_proxies_[id].get();
 
   if (id == INTERFACE_ID_RESOURCE_CREATION)
     function_proxies_[id].reset(new ResourceCreationProxy(this));
+  if (id == INTERFACE_ID_PPB_FONT)
+    function_proxies_[id].reset(new PPB_Font_Proxy(this, NULL));
 
   return function_proxies_[id].get();
 }
 
 void PluginDispatcher::ForceFreeAllInstances() {
   if (!g_instance_to_dispatcher)
     return;
 
   // Iterating will remove each item from the map, so we need to make a copy
   // to avoid things changing out from under is.
@@ skipping 30 matching lines @@
   if (!interface_functions)
     return;
   target_proxies_[info->id].reset(
       info->create_proxy(this, interface_functions));
   *result = true;
 }
 
 }  // namespace proxy
 }  // namespace pp