Mojo: Replace RemotePtr with InterfacePtr and InterfaceImpl

mojo/public/cpp/bindings/tests/sample_service_unittest.cc

 // Copyright 2014 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 <algorithm>
 #include <ostream>
 #include <string>
 
 #include "mojo/public/cpp/bindings/allocation_scope.h"
 #include "mojo/public/cpp/environment/environment.h"
@@ skipping 248 matching lines @@
 
     if (i % 2 == 1)
       std::cout << " ";
     if (i % 8 == 7)
       std::cout << " ";
   }
 }
 
 class ServiceImpl : public Service {
  public:
-  virtual void Frobinate(const Foo& foo, BazOptions baz, ScopedPortHandle port)
+  ServiceImpl() : client_(NULL) {
+  }
+
+  virtual void SetClient(ServiceClient* client) MOJO_OVERRIDE {
+    client_ = client;
+  }
+
+  virtual void Frobinate(const Foo& foo, BazOptions baz, PortPtr port)
       MOJO_OVERRIDE {
     // Users code goes here to handle the incoming Frobinate message.
 
     // We mainly check that we're given the expected arguments.
     CheckFoo(foo);
     EXPECT_EQ(BAZ_EXTRA, baz);
 
     if (g_dump_message_as_text) {
       // Also dump the Foo structure and all of its members.
       std::cout << "Frobinate:" << std::endl;
       int depth = 1;
       Print(depth, "foo", foo);
       Print(depth, "baz", baz);
       Print(depth, "port", port.get());
     }
   }
+
+ private:
+  ServiceClient* client_;
+};
+
+class ServiceProxyImpl : public ServiceProxy {
+ public:
+  explicit ServiceProxyImpl(mojo::MessageReceiver* receiver)
+      : ServiceProxy(receiver) {
+  }
+
+  virtual void SetClient(ServiceClient* client) MOJO_OVERRIDE {
+    assert(false);
+  }
 };
 
 class SimpleMessageReceiver : public mojo::MessageReceiver {
  public:
   virtual bool Accept(mojo::Message* message) MOJO_OVERRIDE {
     // Imagine some IPC happened here.
 
     if (g_dump_message_as_hex) {
       DumpHex(reinterpret_cast<const uint8_t*>(message->data()),
               message->data_num_bytes());
     }
 
     // In the receiving process, an implementation of ServiceStub is known to
     // the system. It receives the incoming message.
     ServiceImpl impl;
 
-    ServiceStub stub(&impl);
+    ServiceStub stub;
+    stub.set_sink(&impl);
     return stub.Accept(message);
   }
 
   virtual bool AcceptWithResponder(mojo::Message* message,
                                    mojo::MessageReceiver* responder)
                                        MOJO_OVERRIDE {
     return false;
   }
 };
 
 TEST(BindingsSampleTest, Basic) {
   mojo::Environment env;
   SimpleMessageReceiver receiver;
 
   // User has a proxy to a Service somehow.
-  Service* service = new ServiceProxy(&receiver);
+  Service* service = new ServiceProxyImpl(&receiver);
 
   // User constructs a message to send.
 
   // Notice that it doesn't matter in what order the structs / arrays are
   // allocated. Here, the various members of Foo are allocated before Foo is
   // allocated.
 
   mojo::AllocationScope scope;
 
   Foo foo = MakeFoo();
   CheckFoo(foo);
 
-  mojo::InterfacePipe<Port, mojo::AnyInterface> pipe;
-  service->Frobinate(foo, Service::BAZ_EXTRA, pipe.handle_to_self.Pass());
+  PortPtr port;
+  service->Frobinate(foo, Service::BAZ_EXTRA, port.Pass());
 }
 
 TEST(BindingsSampleTest, DefaultValues) {
   mojo::Environment env;
   SimpleMessageReceiver receiver;
   mojo::AllocationScope scope;
 
   Bar bar = Bar::Builder().Finish();
   EXPECT_EQ(255, bar.alpha());
 
@@ skipping 24 matching lines @@
 
   EXPECT_EQ(1u, full.shape_masks().size());
   EXPECT_EQ(1 << imported::SHAPE_RECTANGLE, full.shape_masks()[0]);
 
   EXPECT_EQ(imported::SHAPE_CIRCLE, full.thing().shape());
   EXPECT_EQ(imported::COLOR_BLACK, full.thing().color());
 }
 
 }  // namespace
 }  // namespace sample