Mojo: Replace RemotePtr with InterfacePtr and InterfaceImpl

mojo/public/cpp/bindings/tests/handle_passing_unittest.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 "mojo/public/cpp/bindings/allocation_scope.h"
-#include "mojo/public/cpp/bindings/remote_ptr.h"
 #include "mojo/public/cpp/environment/environment.h"
 #include "mojo/public/cpp/test_support/test_utils.h"
 #include "mojo/public/cpp/utility/run_loop.h"
 #include "mojo/public/interfaces/bindings/tests/sample_factory.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace test {
 namespace {
 
 const char kText1[] = "hello";
 const char kText2[] = "world";
 
-class SampleFactoryImpl : public sample::Factory {
+class SampleFactoryImpl : public InterfaceImpl<sample::Factory> {
  public:
-  explicit SampleFactoryImpl(sample::ScopedFactoryClientHandle handle)
-      : client_(handle.Pass(), this) {
+  virtual void OnConnectionError() MOJO_OVERRIDE {
+    delete this;
+  }
+
+  virtual void SetClient(sample::FactoryClient* client) MOJO_OVERRIDE {
+    client_ = client;
   }
 
   virtual void DoStuff(const sample::Request& request,
                        ScopedMessagePipeHandle pipe) MOJO_OVERRIDE {
     std::string text1;
     if (pipe.is_valid())
       EXPECT_TRUE(ReadTextMessage(pipe.get(), &text1));
 
     std::string text2;
     if (request.pipe().is_valid()) {
@@ skipping 29 matching lines @@
     ASSERT_LT(static_cast<int>(data_size), 64);
     ASSERT_EQ(MOJO_RESULT_OK,
               ReadDataRaw(pipe.get(), data, &data_size,
                           MOJO_READ_DATA_FLAG_ALL_OR_NONE));
 
     AllocationScope scope;
     client_->DidStuff2(String(std::string(data)));
   }
 
  private:
-  RemotePtr<sample::FactoryClient> client_;
+  sample::FactoryClient* client_;
   ScopedMessagePipeHandle pipe1_;
 };
 
 class SampleFactoryClientImpl : public sample::FactoryClient {
  public:
-  explicit SampleFactoryClientImpl(sample::ScopedFactoryHandle handle)
-      : factory_(handle.Pass(), this),
-        got_response_(false) {
+  SampleFactoryClientImpl() : got_response_(false) {
   }
 
-  void Start() {
-    expected_text_reply_ = kText1;
-
-    ScopedMessagePipeHandle pipe0;
-    CreateMessagePipe(&pipe0, &pipe1_);
-
-    EXPECT_TRUE(WriteTextMessage(pipe1_.get(), kText1));
-
-    ScopedMessagePipeHandle pipe2;
-    CreateMessagePipe(&pipe2, &pipe3_);
-
-    EXPECT_TRUE(WriteTextMessage(pipe3_.get(), kText2));
-
-    AllocationScope scope;
-    sample::Request::Builder request;
-    request.set_x(1);
-    request.set_pipe(pipe2.Pass());
-    factory_->DoStuff(request.Finish(), pipe0.Pass());
-  }
-
-  void StartNoPipes() {
-    expected_text_reply_.clear();
-
-    AllocationScope scope;
-    sample::Request::Builder request;
-    request.set_x(1);
-    factory_->DoStuff(request.Finish(), ScopedMessagePipeHandle().Pass());
-  }
-
-  // Writes a string to a data pipe and passes the data pipe (consumer) to the
-  // factory.
-  void StartDataPipe() {
-    expected_text_reply_.clear();
-
-    ScopedDataPipeProducerHandle producer_handle;
-    ScopedDataPipeConsumerHandle consumer_handle;
-    MojoCreateDataPipeOptions options = {
-        sizeof(MojoCreateDataPipeOptions),
-        MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,
-        1,
-        1024};
-    ASSERT_EQ(MOJO_RESULT_OK,
-              CreateDataPipe(&options, &producer_handle, &consumer_handle));
-    expected_text_reply_ = "got it";
-    // +1 for \0.
-    uint32_t data_size = static_cast<uint32_t>(expected_text_reply_.size() + 1);
-    ASSERT_EQ(MOJO_RESULT_OK,
-              WriteDataRaw(producer_handle.get(), expected_text_reply_.c_str(),
-                           &data_size, MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
-
-    AllocationScope scope;
-    factory_->DoStuff2(consumer_handle.Pass());
+  void set_expected_text_reply(const std::string& expected_text_reply) {
+    expected_text_reply_ = expected_text_reply;
   }
 
   bool got_response() const {
     return got_response_;
   }
 
   virtual void DidStuff(const sample::Response& response,
                         const String& text_reply) MOJO_OVERRIDE {
     EXPECT_EQ(expected_text_reply_, text_reply.To<std::string>());
 
@@ skipping 14 matching lines @@
 
     got_response_ = true;
   }
 
   virtual void DidStuff2(const String& text_reply) MOJO_OVERRIDE {
     got_response_ = true;
     EXPECT_EQ(expected_text_reply_, text_reply.To<std::string>());
   }
 
  private:
-  RemotePtr<sample::Factory> factory_;
   ScopedMessagePipeHandle pipe1_;
   ScopedMessagePipeHandle pipe3_;
   std::string expected_text_reply_;
   bool got_response_;
 };
 
 class HandlePassingTest : public testing::Test {
  public:
+  virtual void TearDown() {
+    PumpMessages();
+  }
+
   void PumpMessages() {
     loop_.RunUntilIdle();
   }
 
  private:
   Environment env_;
   RunLoop loop_;
 };
 
 TEST_F(HandlePassingTest, Basic) {
-  InterfacePipe<sample::Factory> pipe;
+  sample::FactoryPtr factory;
+  BindToProxy(new SampleFactoryImpl(), &factory);
 
-  SampleFactoryImpl factory(pipe.handle_to_peer.Pass());
-  SampleFactoryClientImpl factory_client(pipe.handle_to_self.Pass());
+  SampleFactoryClientImpl factory_client;
+  factory_client.set_expected_text_reply(kText1);
 
-  factory_client.Start();
+  factory->SetClient(&factory_client);
+
+  ScopedMessagePipeHandle pipe0, pipe1;
+  CreateMessagePipe(&pipe0, &pipe1);
+
+  EXPECT_TRUE(WriteTextMessage(pipe1.get(), kText1));
+
+  ScopedMessagePipeHandle pipe2, pipe3;
+  CreateMessagePipe(&pipe2, &pipe3);
+
+  EXPECT_TRUE(WriteTextMessage(pipe3.get(), kText2));
+
+  {
+    AllocationScope scope;
+    sample::Request::Builder request;
+    request.set_x(1);
+    request.set_pipe(pipe2.Pass());
+    factory->DoStuff(request.Finish(), pipe0.Pass());
+  }
 
   EXPECT_FALSE(factory_client.got_response());
 
   PumpMessages();
 
   EXPECT_TRUE(factory_client.got_response());
 }
 
 TEST_F(HandlePassingTest, PassInvalid) {
-  InterfacePipe<sample::Factory> pipe;
+  sample::FactoryPtr factory;
+  BindToProxy(new SampleFactoryImpl(), &factory);
 
-  SampleFactoryImpl factory(pipe.handle_to_peer.Pass());
-  SampleFactoryClientImpl factory_client(pipe.handle_to_self.Pass());
+  SampleFactoryClientImpl factory_client;
+  factory->SetClient(&factory_client);
 
-  factory_client.StartNoPipes();
+  {
+    AllocationScope scope;
+    sample::Request::Builder request;
+    request.set_x(1);
+    factory->DoStuff(request.Finish(), ScopedMessagePipeHandle().Pass());
+  }
 
   EXPECT_FALSE(factory_client.got_response());
 
   PumpMessages();
 
   EXPECT_TRUE(factory_client.got_response());
 }
 
 // Verifies DataPipeConsumer can be passed and read from.
 TEST_F(HandlePassingTest, DataPipe) {
-  InterfacePipe<sample::Factory> pipe;
+  sample::FactoryPtr factory;
+  BindToProxy(new SampleFactoryImpl(), &factory);
 
-  SampleFactoryImpl factory(pipe.handle_to_peer.Pass());
-  SampleFactoryClientImpl factory_client(pipe.handle_to_self.Pass());
+  SampleFactoryClientImpl factory_client;
+  factory->SetClient(&factory_client);
 
-  ASSERT_NO_FATAL_FAILURE(factory_client.StartDataPipe());
+  // Writes a string to a data pipe and passes the data pipe (consumer) to the
+  // factory.
+  ScopedDataPipeProducerHandle producer_handle;
+  ScopedDataPipeConsumerHandle consumer_handle;
+  MojoCreateDataPipeOptions options = {
+      sizeof(MojoCreateDataPipeOptions),
+      MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,
+      1,
+      1024};
+  ASSERT_EQ(MOJO_RESULT_OK,
+            CreateDataPipe(&options, &producer_handle, &consumer_handle));
+  std::string expected_text_reply = "got it";
+  factory_client.set_expected_text_reply(expected_text_reply);
+  // +1 for \0.
+  uint32_t data_size = static_cast<uint32_t>(expected_text_reply.size() + 1);
+  ASSERT_EQ(MOJO_RESULT_OK,
+            WriteDataRaw(producer_handle.get(), expected_text_reply.c_str(),
+                         &data_size, MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
+
+  {
+    AllocationScope scope;
+    factory->DoStuff2(consumer_handle.Pass());
+  }
 
   EXPECT_FALSE(factory_client.got_response());
 
   PumpMessages();
 
   EXPECT_TRUE(factory_client.got_response());
 }
 
 TEST_F(HandlePassingTest, PipesAreClosed) {
-  InterfacePipe<sample::Factory> pipe;
-  RemotePtr<sample::Factory> factory(pipe.handle_to_self.Pass(), NULL);
+  sample::FactoryPtr factory;
+  BindToProxy(new SampleFactoryImpl(), &factory);
+
+  SampleFactoryClientImpl factory_client;
+  factory->SetClient(&factory_client);
 
   MessagePipe extra_pipe;
 
   MojoHandle handle0_value = extra_pipe.handle0.get().value();
   MojoHandle handle1_value = extra_pipe.handle1.get().value();
 
   {
     AllocationScope scope;
 
     Array<MessagePipeHandle>::Builder pipes(2);
@@ skipping 13 matching lines @@
   }
 
   // We expect the pipes to have been closed.
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(handle0_value));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(handle1_value));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo