Refactor PPAPI proxy resource handling to maintain which host they came from,...

ppapi/proxy/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/dispatcher.h"
 
 #include <string.h>  // For memset.
 
 #include <map>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_sync_channel.h"
+#include "ipc/ipc_test_sink.h"
 #include "ppapi/c/dev/ppb_buffer_dev.h"
 #include "ppapi/c/dev/ppb_char_set_dev.h"
 #include "ppapi/c/dev/ppb_cursor_control_dev.h"
 #include "ppapi/c/dev/ppb_cursor_control_dev.h"
 #include "ppapi/c/dev/ppb_font_dev.h"
 #include "ppapi/c/dev/ppb_fullscreen_dev.h"
 #include "ppapi/c/dev/ppb_fullscreen_dev.h"
 #include "ppapi/c/dev/ppb_testing_dev.h"
 #include "ppapi/c/dev/ppb_var_deprecated.h"
 #include "ppapi/c/pp_errors.h"
@@ skipping 33 matching lines @@
 #include "ppapi/proxy/ppp_instance_proxy.h"
 #include "ppapi/proxy/var_serialization_rules.h"
 
 namespace pp {
 namespace proxy {
 
 Dispatcher::Dispatcher(base::ProcessHandle remote_process_handle,
                        GetInterfaceFunc local_get_interface)
     : pp_module_(0),
       remote_process_handle_(remote_process_handle),
+      test_sink_(NULL),
       disallow_trusted_interfaces_(false),  // TODO(brettw) make this settable.
       local_get_interface_(local_get_interface),
       declared_supported_remote_interfaces_(false),
       callback_tracker_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   memset(id_to_proxy_, 0,
          static_cast<int>(INTERFACE_ID_COUNT) * sizeof(InterfaceProxy*));
 }
 
 Dispatcher::~Dispatcher() {
 }
 
 bool Dispatcher::InitWithChannel(MessageLoop* ipc_message_loop,
                                  const IPC::ChannelHandle& channel_handle,
                                  bool is_client,
                                  base::WaitableEvent* shutdown_event) {
   IPC::Channel::Mode mode = is_client ? IPC::Channel::MODE_CLIENT
                                       : IPC::Channel::MODE_SERVER;
   channel_.reset(new IPC::SyncChannel(channel_handle, mode, this,
                                       ipc_message_loop, false, shutdown_event));
   return true;
 }
 
+void Dispatcher::InitWithTestSink(IPC::TestSink* test_sink) {
+  DCHECK(!test_sink_);
+  test_sink_ = test_sink;
+}
+
 bool Dispatcher::OnMessageReceived(const IPC::Message& msg) {
   // Control messages.
   if (msg.routing_id() == MSG_ROUTING_CONTROL) {
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(Dispatcher, msg)
       IPC_MESSAGE_HANDLER(PpapiMsg_DeclareInterfaces,
                           OnMsgDeclareInterfaces)
       IPC_MESSAGE_HANDLER(PpapiMsg_SupportsInterface, OnMsgSupportsInterface)
       IPC_MESSAGE_FORWARD(PpapiMsg_ExecuteCallback, &callback_tracker_,
                           CallbackTracker::ReceiveExecuteSerializedCallback)
@@ skipping 50 matching lines @@
   if (!proxy.get())
     return NULL;  // Don't know how to proxy this interface.
 
   // Save our proxy.
   proxies_[interface] = proxy;
   id_to_proxy_[proxy->GetInterfaceId()] = proxy.get();
   return proxy->GetSourceInterface();
 }
 
 bool Dispatcher::Send(IPC::Message* msg) {
+  if (test_sink_)
+    return test_sink_->Send(msg);
   return channel_->Send(msg);
 }
 
 bool Dispatcher::RemoteSupportsTargetInterface(const std::string& interface) {
   bool result = false;
   Send(new PpapiMsg_SupportsInterface(interface, &result));
   return result;
 }
 
 bool Dispatcher::IsInterfaceTrusted(const std::string& interface) {
@@ skipping 103 matching lines @@
     if (interface_name == PPB_URLLOADERTRUSTED_INTERFACE)
       return new PPB_URLLoaderTrusted_Proxy(this, interface_functions);
   }
 
   return NULL;
 }
 
 }  // namespace proxy
 }  // namespace pp