1 // Copyright 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "ppapi/proxy/resource_reply_thread_registrar.h" 6 7 #include "base/logging.h" 8 #include "base/message_loop/message_loop_proxy.h" 9 #include "ipc/ipc_message.h" 10 #include "ppapi/proxy/resource_message_params.h" 11 #include "ppapi/shared_impl/proxy_lock.h" 12 #include "ppapi/shared_impl/tracked_callback.h" 13 14 namespace ppapi { 15 namespace proxy { 16 17 ResourceReplyThreadRegistrar::ResourceReplyThreadRegistrar( 18 scoped_refptr<base::MessageLoopProxy> main_thread) 19 : main_thread_(main_thread) { 20 } 21 22 ResourceReplyThreadRegistrar::~ResourceReplyThreadRegistrar() { 23 } 24 25 void ResourceReplyThreadRegistrar::Register( 26 PP_Resource resource, 27 int32_t sequence_number, 28 scoped_refptr<TrackedCallback> reply_thread_hint) { 29 ProxyLock::AssertAcquiredDebugOnly(); 30 31 // Use the main thread if |reply_thread_hint| is NULL or blocking. 32 if (!reply_thread_hint.get() || reply_thread_hint->is_blocking()) 33 return; 34 35 DCHECK(reply_thread_hint->target_loop()); 36 scoped_refptr<base::MessageLoopProxy> reply_thread( 37 reply_thread_hint->target_loop()->GetMessageLoopProxy()); 38 { 39 base::AutoLock auto_lock(lock_); 40 41 if (reply_thread.get() == main_thread_.get()) 42 return; 43 44 map_[resource][sequence_number] = reply_thread; 45 } 46 } 47 48 void ResourceReplyThreadRegistrar::Unregister(PP_Resource resource) { 49 base::AutoLock auto_lock(lock_); 50 map_.erase(resource); 51 } 52 53 void ResourceReplyThreadRegistrar::HandleOnIOThread(uint32 nested_msg_type) { 54 base::AutoLock auto_lock(lock_); 55 io_thread_message_types_.insert(nested_msg_type); 56 } 57 58 scoped_refptr<base::MessageLoopProxy> 59 ResourceReplyThreadRegistrar::GetTargetThread( 60 const ResourceMessageReplyParams& reply_params, 61 const IPC::Message& nested_msg) { 62 base::AutoLock auto_lock(lock_); 63 ResourceMap::iterator resource_iter = map_.find(reply_params.pp_resource()); 64 if (resource_iter != map_.end()) { 65 SequenceThreadMap::iterator sequence_thread_iter = 66 resource_iter->second.find(reply_params.sequence()); 67 if (sequence_thread_iter != resource_iter->second.end()) { 68 scoped_refptr<base::MessageLoopProxy> target = 69 sequence_thread_iter->second; 70 resource_iter->second.erase(sequence_thread_iter); 71 return target; 72 } 73 } 74 75 if (io_thread_message_types_.count(nested_msg.type()) != 0) 76 return scoped_refptr<base::MessageLoopProxy>(); 77 78 return main_thread_; 79 } 80 81 } // namespace proxy 82 } // namespace ppapi 83