Pepper: Introduce ThreadAwareCallback.

ppapi/proxy/device_enumeration_resource_helper.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 "ppapi/proxy/device_enumeration_resource_helper.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "ipc/ipc_message.h"
@@ skipping 12 matching lines @@
 #include "ppapi/shared_impl/tracked_callback.h"
 
 namespace ppapi {
 namespace proxy {
 
 DeviceEnumerationResourceHelper::DeviceEnumerationResourceHelper(
     PluginResource* owner)
     : owner_(owner),
       pending_enumerate_devices_(false),
       monitor_callback_id_(0),
-      monitor_callback_(NULL),
       monitor_user_data_(NULL) {
 }
 
 DeviceEnumerationResourceHelper::~DeviceEnumerationResourceHelper() {
 }
 
 int32_t DeviceEnumerationResourceHelper::EnumerateDevices0_2(
     PP_Resource* devices,
     scoped_refptr<TrackedCallback> callback) {
   if (pending_enumerate_devices_)
@@ skipping 39 matching lines @@
   if (result == PP_OK)
     result = WriteToArrayOutput(devices, output);
 
   return result;
 }
 
 int32_t DeviceEnumerationResourceHelper::MonitorDeviceChange(
     PP_MonitorDeviceChangeCallback callback,
     void* user_data) {
   monitor_callback_id_++;
-  monitor_callback_ = callback;
+  monitor_callback_.reset(
+      new ThreadAwareCallback<PP_MonitorDeviceChangeCallback>(callback));
   monitor_user_data_ = user_data;
 
   if (callback) {
     owner_->Post(PluginResource::RENDERER,
                  PpapiHostMsg_DeviceEnumeration_MonitorDeviceChange(
                      monitor_callback_id_));
   } else {
     owner_->Post(PluginResource::RENDERER,
                  PpapiHostMsg_DeviceEnumeration_StopMonitoringDeviceChange());
   }
   return PP_OK;
 }
 
 bool DeviceEnumerationResourceHelper::HandleReply(
     const ResourceMessageReplyParams& params,
     const IPC::Message& msg) {
   IPC_BEGIN_MESSAGE_MAP(DeviceEnumerationResourceHelper, msg)
     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
         PpapiPluginMsg_DeviceEnumeration_NotifyDeviceChange,
         OnPluginMsgNotifyDeviceChange)
     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL_UNHANDLED(return false)
   IPC_END_MESSAGE_MAP()
 
   return true;
 }
 
 void DeviceEnumerationResourceHelper::LastPluginRefWasDeleted() {
   // Make sure that no further notifications are sent to the plugin.
   monitor_callback_id_++;
-  monitor_callback_ = NULL;
+  monitor_callback_.reset();
   monitor_user_data_ = NULL;
 
   // There is no need to do anything with pending callback of
   // EnumerateDevices(), because OnPluginMsgEnumerateDevicesReply*() will handle
   // that properly.
 }
 
 void DeviceEnumerationResourceHelper::OnPluginMsgEnumerateDevicesReply0_2(
     PP_Resource* devices_resource,
     scoped_refptr<TrackedCallback> callback,
@@ skipping 37 matching lines @@
 
 void DeviceEnumerationResourceHelper::OnPluginMsgNotifyDeviceChange(
     const ResourceMessageReplyParams& /* params */,
     uint32_t callback_id,
     const std::vector<DeviceRefData>& devices) {
   if (monitor_callback_id_ != callback_id) {
     // A new callback or NULL has been set.
     return;
   }
 
-  CHECK(monitor_callback_);
+  CHECK(monitor_callback_.get());
 
   scoped_array<PP_Resource> elements;
   uint32_t size = devices.size();
   if (size > 0) {
     elements.reset(new PP_Resource[size]);
     for (size_t index = 0; index < size; ++index) {
       PPB_DeviceRef_Shared* device_object = new PPB_DeviceRef_Shared(
           OBJECT_IS_PROXY, owner_->pp_instance(), devices[index]);
       elements[index] = device_object->GetReference();
     }
   }
 
-  // TODO(yzshen): make sure |monitor_callback_| is called on the same thread as
-  // the one on which MonitorDeviceChange() is called.
-  CallWhileUnlocked(base::Bind(monitor_callback_, monitor_user_data_, size,
-                               elements.get()));
+  monitor_callback_->RunOnTargetThread(monitor_user_data_, size,
+                                       elements.get());
   for (size_t index = 0; index < size; ++index)
     PpapiGlobals::Get()->GetResourceTracker()->ReleaseResource(elements[index]);
 }
 
 int32_t DeviceEnumerationResourceHelper::WriteToArrayOutput(
     const std::vector<DeviceRefData>& devices,
     const PP_ArrayOutput& output) {
   ArrayWriter writer(output);
   if (!writer.is_valid())
     return PP_ERROR_BADARGUMENT;
 
   std::vector<scoped_refptr<Resource> > device_resources;
   for (size_t i = 0; i < devices.size(); ++i) {
     device_resources.push_back(new PPB_DeviceRef_Shared(
         OBJECT_IS_PROXY, owner_->pp_instance(), devices[i]));
   }
   if (!writer.StoreResourceVector(device_resources))
     return PP_ERROR_FAILED;
 
   return PP_OK;
 }
 
 }  // namespace proxy
 }  // namespace ppapi