attachment broker wip

components/nacl/loader/nacl_listener.cc

 // Copyright 2013 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 "components/nacl/loader/nacl_listener.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 129 matching lines @@
 // (browser/renderer) process, and starts to listen it on the thread where
 // the given message_loop_proxy runs.
 // Also, creates and sets the corresponding NaClDesc to the given nap with
 // the FD #.
 void SetUpIPCAdapter(
     IPC::ChannelHandle* handle,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     struct NaClApp* nap,
     int nacl_fd,
     NaClIPCAdapter::ResolveFileTokenCallback resolve_file_token_cb,
-    NaClIPCAdapter::OpenResourceCallback open_resource_cb) {
-  scoped_refptr<NaClIPCAdapter> ipc_adapter(new NaClIPCAdapter(
-      *handle, task_runner.get(), resolve_file_token_cb, open_resource_cb));
+    NaClIPCAdapter::OpenResourceCallback open_resource_cb,
+    IPC::AttachmentBroker* broker) {
+  scoped_refptr<NaClIPCAdapter> ipc_adapter(
+      new NaClIPCAdapter(*handle, task_runner.get(), resolve_file_token_cb,
+                         open_resource_cb, broker));
   ipc_adapter->ConnectChannel();
 #if defined(OS_POSIX)
   handle->socket =
       base::FileDescriptor(ipc_adapter->TakeClientFileDescriptor());
 #endif
 
   // Pass a NaClDesc to the untrusted side. This will hold a ref to the
   // NaClIPCAdapter.
   NaClAppSetDesc(nap, nacl_fd, ipc_adapter->MakeNaClDesc());
 }
@@ skipping 24 matching lines @@
     if (!listener_->Send(new NaClProcessMsg_SetKnownToValidate(signature))) {
       LOG(ERROR) << "Failed to update NaCl validation cache.";
     }
   }
 
  private:
   // The listener never dies, otherwise this might be a dangling reference.
   NaClListener* listener_;
 };
 
-
-NaClListener::NaClListener() : shutdown_event_(true, false),
-                               io_thread_("NaCl_IOThread"),
+NaClListener::NaClListener(IPC::AttachmentBroker* broker)
+    : shutdown_event_(true, false),
+      io_thread_("NaCl_IOThread"),
+      broker_(broker),
 #if defined(OS_LINUX)
-                               prereserved_sandbox_size_(0),
+      prereserved_sandbox_size_(0),
 #endif
 #if defined(OS_POSIX)
-                               number_of_cores_(-1),  // unknown/error
+      number_of_cores_(-1),  // unknown/error
 #endif
-                               main_loop_(NULL),
-                               is_started_(false) {
+      main_loop_(NULL),
+      is_started_(false) {
   io_thread_.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
   DCHECK(g_listener == NULL);
   g_listener = this;
 }
 
 NaClListener::~NaClListener() {
   NOTREACHED();
   shutdown_event_.Signal();
   g_listener = NULL;
@@ skipping 40 matching lines @@
 
 void NaClListener::Listen() {
   std::string channel_name =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kProcessChannelID);
   channel_ = IPC::SyncChannel::Create(this, io_thread_.task_runner().get(),
                                       &shutdown_event_);
   filter_ = new IPC::SyncMessageFilter(&shutdown_event_);
   channel_->AddFilter(filter_.get());
   channel_->AddFilter(new FileTokenMessageFilter());
-  channel_->Init(channel_name, IPC::Channel::MODE_CLIENT, true);
+  channel_->Init(channel_name, IPC::Channel::MODE_CLIENT, true, broker_);
   main_loop_ = base::MessageLoop::current();
   main_loop_->Run();
 }
 
 bool NaClListener::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(NaClListener, msg)
       IPC_MESSAGE_HANDLER(NaClProcessMsg_AddPrefetchedResource,
                           OnAddPrefetchedResource)
       IPC_MESSAGE_HANDLER(NaClProcessMsg_Start, OnStart)
@@ skipping 75 matching lines @@
     browser_handle = IPC::Channel::GenerateVerifiedChannelID("nacl");
     ppapi_renderer_handle = IPC::Channel::GenerateVerifiedChannelID("nacl");
     manifest_service_handle = IPC::Channel::GenerateVerifiedChannelID("nacl");
 
     // Create the PPAPI IPC channels between the NaCl IRT and the host
     // (browser/renderer) processes. The IRT uses these channels to
     // communicate with the host and to initialize the IPC dispatchers.
     SetUpIPCAdapter(&browser_handle, io_thread_.task_runner(), nap,
                     NACL_CHROME_DESC_BASE,
                     NaClIPCAdapter::ResolveFileTokenCallback(),
-                    NaClIPCAdapter::OpenResourceCallback());
+                    NaClIPCAdapter::OpenResourceCallback(), broker_);
     SetUpIPCAdapter(&ppapi_renderer_handle, io_thread_.task_runner(), nap,
                     NACL_CHROME_DESC_BASE + 1,
                     NaClIPCAdapter::ResolveFileTokenCallback(),
-                    NaClIPCAdapter::OpenResourceCallback());
+                    NaClIPCAdapter::OpenResourceCallback(), broker_);
     SetUpIPCAdapter(
         &manifest_service_handle, io_thread_.task_runner(), nap,
         NACL_CHROME_DESC_BASE + 2,
         base::Bind(&NaClListener::ResolveFileToken, base::Unretained(this)),
-        base::Bind(&NaClListener::OnOpenResource, base::Unretained(this)));
+        base::Bind(&NaClListener::OnOpenResource, base::Unretained(this)),
+        broker_);
   }
 
   trusted_listener_ =
       new NaClTrustedListener(IPC::Channel::GenerateVerifiedChannelID("nacl"),
                               io_thread_.task_runner().get(), &shutdown_event_);
   if (!Send(new NaClProcessHostMsg_PpapiChannelsCreated(
           browser_handle,
           ppapi_renderer_handle,
           trusted_listener_->TakeClientChannelHandle(),
           manifest_service_handle)))
@@ skipping 112 matching lines @@
 }
 
 void NaClListener::OnFileTokenResolved(
     uint64_t token_lo,
     uint64_t token_hi,
     IPC::PlatformFileForTransit ipc_fd,
     base::FilePath file_path) {
   resolved_cb_.Run(ipc_fd, file_path);
   resolved_cb_.Reset();
 }