ipc: Make a new class PlaceholderBrokerableAttachment.

ipc/ipc_channel_reader_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 <set>
 
 #include "ipc/attachment_broker.h"
 #include "ipc/brokerable_attachment.h"
 #include "ipc/ipc_channel_reader.h"
+#include "ipc/placeholder_brokerable_attachment.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if USE_ATTACHMENT_BROKER
 namespace IPC {
 namespace internal {
 
 namespace {
 
 class MockAttachment : public BrokerableAttachment {
  public:
-  MockAttachment(int internal_state) : internal_state_(internal_state) {}
+  MockAttachment() {}
   MockAttachment(BrokerableAttachment::AttachmentId id)
-      : BrokerableAttachment(id, true), internal_state_(-1) {}
-
-  void PopulateWithAttachment(const BrokerableAttachment* attachment) override {
-    const MockAttachment* mock_attachment =
-        static_cast<const MockAttachment*>(attachment);
-    internal_state_ = mock_attachment->internal_state_;
-  }
+      : BrokerableAttachment(id) {}
 
 #if defined(OS_POSIX)
   base::PlatformFile TakePlatformFile() override {
     return base::PlatformFile();
   }
 #endif  // OS_POSIX
 
   BrokerableType GetBrokerableType() const override { return WIN_HANDLE; }
 
  private:
   ~MockAttachment() override {}
-  // Internal state differentiates MockAttachments.
-  int internal_state_;
 };
 
 class MockAttachmentBroker : public AttachmentBroker {
  public:
   typedef std::set<scoped_refptr<BrokerableAttachment>> AttachmentSet;
 
   bool SendAttachmentToProcess(const BrokerableAttachment* attachment,
                                base::ProcessId destination_process) override {
     return false;
   }
@@ skipping 44 matching lines @@
   Message* last_dispatched_message_;
   AttachmentBroker* broker_;
 };
 
 }  // namespace
 
 TEST(ChannelReaderTest, AttachmentAlreadyBrokered) {
   MockAttachmentBroker broker;
   MockChannelReader reader;
   reader.set_broker(&broker);
-  scoped_refptr<MockAttachment> attachment(new MockAttachment(5));
+  scoped_refptr<MockAttachment> attachment(new MockAttachment);
   broker.AddAttachment(attachment);
 
   Message* m = new Message;
-  MockAttachment* needs_brokering_attachment =
-      new MockAttachment(attachment->GetIdentifier());
+  PlaceholderBrokerableAttachment* needs_brokering_attachment =
+      new PlaceholderBrokerableAttachment(attachment->GetIdentifier());
   EXPECT_TRUE(m->WriteAttachment(needs_brokering_attachment));
   reader.AddMessageForDispatch(m);
   EXPECT_EQ(ChannelReader::DISPATCH_FINISHED, reader.DispatchMessages());
   EXPECT_EQ(m, reader.get_last_dispatched_message());
 }
 
 TEST(ChannelReaderTest, AttachmentNotYetBrokered) {
   MockAttachmentBroker broker;
   MockChannelReader reader;
   reader.set_broker(&broker);
-  scoped_refptr<MockAttachment> attachment(new MockAttachment(5));
+  scoped_refptr<MockAttachment> attachment(new MockAttachment);
 
   Message* m = new Message;
-  MockAttachment* needs_brokering_attachment =
-      new MockAttachment(attachment->GetIdentifier());
+  PlaceholderBrokerableAttachment* needs_brokering_attachment =
+      new PlaceholderBrokerableAttachment(attachment->GetIdentifier());
   EXPECT_TRUE(m->WriteAttachment(needs_brokering_attachment));
   reader.AddMessageForDispatch(m);
   EXPECT_EQ(ChannelReader::DISPATCH_WAITING_ON_BROKER,
             reader.DispatchMessages());
   EXPECT_EQ(nullptr, reader.get_last_dispatched_message());
 
   broker.AddAttachment(attachment);
   EXPECT_EQ(m, reader.get_last_dispatched_message());
 }
 
 }  // namespace internal
 }  // namespace IPC
 #endif  // USE_ATTACHMENT_BROKER