ppapi/proxy/resource_reply_thread_registrar.cc

   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