First pass at making the proxy handle multiple renderers. This associates the...

ppapi/proxy/ppb_image_data_proxy.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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/ppb_image_data_proxy.h"
 
 #include <string.h>  // For memcpy
 
 #include <vector>
 
 #include "base/logging.h"
 #include "build/build_config.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/trusted/ppb_image_data_trusted.h"
 #include "ppapi/proxy/image_data.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
+#include "ppapi/proxy/plugin_resource_tracker.h"
 #include "ppapi/proxy/ppapi_messages.h"
 
 namespace pp {
 namespace proxy {
 
 namespace {
 
 PP_ImageDataFormat GetNativeImageDataFormat() {

[piman, 2011/01/20 00:26:23]

Here too, it sounds like we should pass a PP_Instance (and below).

[brettw, 2011/01/20 00:48:45]

I was less sure what to do about these ones. Since this represents "global
machine state" that we easily know in advance, we can easily have the renderer
send all of this global settings to the plugin when it starts and have them
available here. This doesn't work as well for the audio config since that might
be complicated to retrieve.

That seemed like kind of a lot of work for just these simple two cases, I put
the code in a shared place. Since this can be figured out at compile time, it
seemed OK for the proxy to "just know" what the right values are.

[piman, 2011/01/20 01:05:12]

I just want to make sure we don't design ourselves into a corner. For example if
in the future we decide that accelerated compositing expects a different format
from regular painting, then it becomes context-dependent and we would need the
instance.

[brettw, 2011/01/20 05:52:13]

This flag means more than just the fast compositing mode, it also tells you what
format you need to use to get the platform-specific software font drawing to
work. It seems like this will always be a specific value for an OS. If
compositing requires a different order, I think we'd probably just need to make
it work somehow.

-  int32 format = 0;
-  PluginDispatcher::Get()->Send(
-      new PpapiHostMsg_PPBImageData_GetNativeImageDataFormat(
-          INTERFACE_ID_PPB_IMAGE_DATA, &format));
-  return static_cast<PP_ImageDataFormat>(format);
+  return ImageData::GetNativeImageDataFormat();
 }
 
 PP_Bool IsImageDataFormatSupported(PP_ImageDataFormat format) {
-  PP_Bool supported = PP_FALSE;
-  PluginDispatcher::Get()->Send(
-      new PpapiHostMsg_PPBImageData_IsImageDataFormatSupported(
-          INTERFACE_ID_PPB_IMAGE_DATA, static_cast<int32_t>(format),
-          &supported));
-  return supported;
+  return BoolToPPBool(ImageData::IsImageDataFormatSupported(format));
 }
 
 PP_Resource Create(PP_Instance instance,
                    PP_ImageDataFormat format,
                    const PP_Size* size,
                    PP_Bool init_to_zero) {
+  PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
+  if (!dispatcher)
+    return PP_ERROR_BADARGUMENT;
+
   PP_Resource result = 0;
   std::string image_data_desc;
   ImageHandle image_handle = ImageData::NullHandle;
-  PluginDispatcher::Get()->Send(
-      new PpapiHostMsg_PPBImageData_Create(
-          INTERFACE_ID_PPB_IMAGE_DATA, instance, format, *size, init_to_zero,
-          &result, &image_data_desc, &image_handle));
+  dispatcher->Send(new PpapiHostMsg_PPBImageData_Create(
+      INTERFACE_ID_PPB_IMAGE_DATA, instance, format, *size, init_to_zero,
+      &result, &image_data_desc, &image_handle));
 
   if (result && image_data_desc.size() == sizeof(PP_ImageDataDesc)) {
     // We serialize the PP_ImageDataDesc just by copying to a string.
     PP_ImageDataDesc desc;
     memcpy(&desc, image_data_desc.data(), sizeof(PP_ImageDataDesc));
 
-    linked_ptr<ImageData> object(
-        new ImageData(desc, image_handle));
-    PluginDispatcher::Get()->plugin_resource_tracker()->AddResource(
-        result, object);
+    linked_ptr<ImageData> object(new ImageData(instance, desc, image_handle));
+    PluginResourceTracker::GetInstance()->AddResource(result, object);
   }
   return result;
 }
 
 PP_Bool IsImageData(PP_Resource resource) {
   ImageData* object = PluginResource::GetAs<ImageData>(resource);
   return BoolToPPBool(!!object);
 }
 
 PP_Bool Describe(PP_Resource resource, PP_ImageDataDesc* desc) {
@@ skipping 41 matching lines @@
   return &ppb_imagedata;
 }
 
 InterfaceID PPB_ImageData_Proxy::GetInterfaceId() const {
   return INTERFACE_ID_PPB_IMAGE_DATA;
 }
 
 bool PPB_ImageData_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_ImageData_Proxy, msg)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBImageData_GetNativeImageDataFormat,
-                        OnMsgGetNativeImageDataFormat)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBImageData_IsImageDataFormatSupported,
-                        OnMsgIsImageDataFormatSupported)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBImageData_Create, OnMsgCreate)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   // FIXME(brettw) handle bad messages!
   return handled;
 }
 
-void PPB_ImageData_Proxy::OnMsgGetNativeImageDataFormat(int32* result) {
-  *result = ppb_image_data_target()->GetNativeImageDataFormat();
-}
-
-void PPB_ImageData_Proxy::OnMsgIsImageDataFormatSupported(int32 format,
-                                                          PP_Bool* result) {
-  *result = ppb_image_data_target()->IsImageDataFormatSupported(
-      static_cast<PP_ImageDataFormat>(format));
-}
-
 void PPB_ImageData_Proxy::OnMsgCreate(PP_Instance instance,
                                       int32_t format,
                                       const PP_Size& size,
                                       PP_Bool init_to_zero,
                                       PP_Resource* result,
                                       std::string* image_data_desc,
                                       ImageHandle* result_image_handle) {
   *result = ppb_image_data_target()->Create(
       instance, static_cast<PP_ImageDataFormat>(format), &size, init_to_zero);
   *result_image_handle = ImageData::NullHandle;
@@ skipping 13 matching lines @@
     if (trusted) {
       int32_t handle;
       if (trusted->GetSharedMemory(*result, &handle, &byte_count) == PP_OK)
           *result_image_handle = ImageData::HandleFromInt(handle);
     }
   }
 }
 
 }  // namespace proxy
 }  // namespace pp