ipc: Create AttachmentBrokerPrivileged and AttachmentBrokerUnprivileged.

ipc/attachment_broker_privileged_win_unittest.cc

 // Copyright 2015 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 "build/build_config.h"
 
 #include <windows.h>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "ipc/attachment_broker_privileged_win.h"
-#include "ipc/attachment_broker_win.h"
+#include "ipc/attachment_broker_unprivileged_win.h"
 #include "ipc/handle_attachment_win.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_test_base.h"
 
 namespace {
 
 const char kDataBuffer[] = "This is some test data to write to the file.";
 
 // Returns the contents of the file represented by |h| as a std::string.
@@ skipping 119 matching lines @@
 
   void SetUp() override {
     IPCTestBase::SetUp();
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &temp_path_));
   }
 
   void TearDown() override { IPCTestBase::TearDown(); }
 
   // Takes ownership of |broker|. Has no effect if called after CommonSetUp().
-  void set_broker(IPC::AttachmentBrokerWin* broker) { broker_.reset(broker); }
+  void set_broker(IPC::AttachmentBrokerUnprivilegedWin* broker) {
+    broker_.reset(broker);
+  }
 
   void CommonSetUp() {
     if (!broker_.get())
-      set_broker(new IPC::AttachmentBrokerWin);
+      set_broker(new IPC::AttachmentBrokerUnprivilegedWin);
     broker_->AddObserver(&observer_);
     set_attachment_broker(broker_.get());
     CreateChannel(&proxy_listener_);
     broker_->set_sender(channel());
     ASSERT_TRUE(ConnectChannel());
     ASSERT_TRUE(StartClient());
   }
 
   void CommonTearDown() {
     // Close the channel so the client's OnChannelError() gets fired.
@@ skipping 19 matching lines @@
     IPC::Message* message =
         new IPC::Message(0, 2, IPC::Message::PRIORITY_NORMAL);
     message->WriteInt(message_index_++);
     scoped_refptr<IPC::internal::HandleAttachmentWin> attachment(
         new IPC::internal::HandleAttachmentWin(h));
     ASSERT_TRUE(message->WriteAttachment(attachment));
     sender()->Send(message);
   }
 
   ProxyListener* get_proxy_listener() { return &proxy_listener_; }
-  IPC::AttachmentBrokerWin* get_broker() { return broker_.get(); }
+  IPC::AttachmentBrokerUnprivilegedWin* get_broker() { return broker_.get(); }
   MockObserver* get_observer() { return &observer_; }
 
  private:
   base::ScopedTempDir temp_dir_;
   base::FilePath temp_path_;
   int message_index_;
   ProxyListener proxy_listener_;
-  scoped_ptr<IPC::AttachmentBrokerWin> broker_;
+  scoped_ptr<IPC::AttachmentBrokerUnprivilegedWin> broker_;
   MockObserver observer_;
 };
 
 // A broker which always sets the current process as the destination process
 // for attachments.
-class MockBroker : public IPC::AttachmentBrokerWin {
+class MockBroker : public IPC::AttachmentBrokerUnprivilegedWin {
  public:
   MockBroker() {}
   ~MockBroker() override {}
   bool SendAttachmentToProcess(const IPC::BrokerableAttachment* attachment,
                                base::ProcessId destination_process) override {
-    return IPC::AttachmentBrokerWin::SendAttachmentToProcess(
+    return IPC::AttachmentBrokerUnprivilegedWin::SendAttachmentToProcess(
         attachment, base::Process::Current().Pid());
   }
 };
 
 // An unprivileged process makes a file HANDLE, and writes a string to it. The
 // file HANDLE is sent to the privileged process using the attachment broker.
 // The privileged process dups the HANDLE into its own HANDLE table. This test
 // checks that the file has the same contents in the privileged process.
 TEST_F(IPCAttachmentBrokerPrivilegedWinTest, SendHandle) {
   Init("SendHandle");
@@ skipping 159 matching lines @@
   // Do nothing special. The default behavior already runs the
   // AttachmentBrokerPrivilegedWin.
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendHandleToSelf) {
   return CommonPrivilegedProcessMain(&SendHandleToSelfCallback,
                                      "SendHandleToSelf");
 }
 
 }  // namespace