Mojo: Replace RemotePtr with InterfacePtr and InterfaceImpl

mojo/apps/js/test/js_to_cpp_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 "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "gin/public/isolate_holder.h"
 #include "mojo/apps/js/mojo_runner_delegate.h"
 #include "mojo/apps/js/test/js_to_cpp.mojom.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/common/test/test_utils.h"
 #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/system/core.h"
 #include "mojo/public/cpp/system/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace js {
 namespace {
 
 // Negative numbers with different values in each byte, the last of
@@ skipping 80 matching lines @@
     EXPECT_EQ(std::string("one"), arg.string_array()[0].To<std::string>());
     EXPECT_EQ(std::string("two"), arg.string_array()[1].To<std::string>());
     EXPECT_EQ(std::string("three"), arg.string_array()[2].To<std::string>());
 }
 
 // Base Provider implementation class. It's expected that tests subclass and
 // override the appropriate Provider functions. When test is done quit the
 // run_loop().
 class CppSideConnection : public js_to_cpp::CppSide {
  public:
-  CppSideConnection() : run_loop_(NULL), client_(NULL) {
+  CppSideConnection() : run_loop_(NULL), js_side_(NULL) {
   }
   virtual ~CppSideConnection() {}
 
   void set_run_loop(base::RunLoop* run_loop) { run_loop_ = run_loop; }
   base::RunLoop* run_loop() { return run_loop_; }
 
-  void set_client(js_to_cpp::JsSide* client) { client_ = client; }
-  js_to_cpp::JsSide* client() { return client_; }
+  void set_js_side(js_to_cpp::JsSide* js_side) { js_side_ = js_side; }
+  js_to_cpp::JsSide* js_side() { return js_side_; }
 
   // js_to_cpp::CppSide:
   virtual void StartTest() OVERRIDE {
     NOTREACHED();
   }
 
   virtual void TestFinished() OVERRIDE {
     NOTREACHED();
   }
 
   virtual void PingResponse() OVERRIDE {
     NOTREACHED();
   }
 
   virtual void EchoResponse(const js_to_cpp::EchoArgs& arg1,
                             const js_to_cpp::EchoArgs& arg2) OVERRIDE {
     NOTREACHED();
   }
 
   virtual void BitFlipResponse(const js_to_cpp::EchoArgs& arg1) OVERRIDE {
     NOTREACHED();
   }
 
  protected:
   base::RunLoop* run_loop_;
-  js_to_cpp::JsSide* client_;
+  js_to_cpp::JsSide* js_side_;
 
  private:
   Environment environment;
   DISALLOW_COPY_AND_ASSIGN(CppSideConnection);
 };
 
 // Trivial test to verify a message sent from JS is received.
 class PingCppSideConnection : public CppSideConnection {
  public:
   explicit PingCppSideConnection() : got_message_(false) {}
   virtual ~PingCppSideConnection() {}
 
   // js_to_cpp::CppSide:
   virtual void StartTest() OVERRIDE {
-    client_->Ping();
+    js_side_->Ping();
   }
 
   virtual void PingResponse() OVERRIDE {
     got_message_ = true;
     run_loop()->Quit();
   }
 
   bool DidSucceed() {
     return got_message_;
   }
 
  private:
   bool got_message_;
   DISALLOW_COPY_AND_ASSIGN(PingCppSideConnection);
 };
 
 // Test that parameters are passed with correct values.
 class EchoCppSideConnection : public CppSideConnection {
  public:
   explicit EchoCppSideConnection() :
       message_count_(0),
       termination_seen_(false) {
   }
   virtual ~EchoCppSideConnection() {}
 
   // js_to_cpp::CppSide:
   virtual void StartTest() OVERRIDE {
     AllocationScope scope;
-    client_->Echo(kExpectedMessageCount, BuildSampleEchoArgs());
+    js_side_->Echo(kExpectedMessageCount, BuildSampleEchoArgs());
   }
 
   virtual void EchoResponse(const js_to_cpp::EchoArgs& arg1,
                             const js_to_cpp::EchoArgs& arg2) OVERRIDE {
     message_count_ += 1;
     CheckSampleEchoArgs(arg1);
     EXPECT_EQ(-1, arg2.si64());
     EXPECT_EQ(-1, arg2.si32());
     EXPECT_EQ(-1, arg2.si16());
     EXPECT_EQ(-1, arg2.si8());
@@ skipping 18 matching lines @@
 
 // Test that corrupted messages don't wreak havoc.
 class BitFlipCppSideConnection : public CppSideConnection {
  public:
   explicit BitFlipCppSideConnection() : termination_seen_(false) {}
   virtual ~BitFlipCppSideConnection() {}
 
   // js_to_cpp::CppSide:
   virtual void StartTest() OVERRIDE {
     AllocationScope scope;
-    client_->BitFlip(BuildSampleEchoArgs());
+    js_side_->BitFlip(BuildSampleEchoArgs());
   }
 
   virtual void BitFlipResponse(const js_to_cpp::EchoArgs& arg1) OVERRIDE {
     // TODO(tsepez): How to check, may be corrupt in various ways.
   }
 
   virtual void TestFinished() OVERRIDE {
     termination_seen_ = true;
     run_loop()->Quit();
   }
 
   bool DidSucceed() {
     return termination_seen_;
   }
 
  private:
   bool termination_seen_;
   DISALLOW_COPY_AND_ASSIGN(BitFlipCppSideConnection);
 };
 
 }  // namespace
 
 class JsToCppTest : public testing::Test {
  public:
   JsToCppTest() {}
 
   void RunTest(const std::string& test, CppSideConnection* cpp_side) {
     cpp_side->set_run_loop(&run_loop_);
-    InterfacePipe<js_to_cpp::CppSide, js_to_cpp::JsSide> pipe;
-    RemotePtr<js_to_cpp::JsSide> js_side;
-    js_side.reset(pipe.handle_to_peer.Pass(), cpp_side);
-    js_side.router_for_testing()->
+
+    MessagePipe pipe;
+    js_to_cpp::JsSidePtr js_side =
+        MakeProxy<js_to_cpp::JsSide>(pipe.handle0.Pass());
+    js_side->SetClient(cpp_side);
+
+    js_side.internal_state()->router()->
         set_enforce_errors_from_incoming_receiver(false);
-    cpp_side->set_client(js_side.get());
+
+    cpp_side->set_js_side(js_side.get());
 
     gin::IsolateHolder instance(gin::IsolateHolder::kStrictMode);
     apps::MojoRunnerDelegate delegate;
     gin::ShellRunner runner(&delegate, instance.isolate());
-    delegate.Start(&runner, pipe.handle_to_self.release().value(),
-                   test);
+    delegate.Start(&runner, pipe.handle1.release().value(), test);
 
     run_loop_.Run();
   }
 
  private:
   base::MessageLoop loop;
   base::RunLoop run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(JsToCppTest);
 };
@@ skipping 21 matching lines @@
   if (IsRunningOnIsolatedBot())
     return;
 
   BitFlipCppSideConnection cpp_side_connection;
   RunTest("mojo/apps/js/test/js_to_cpp_unittest", &cpp_side_connection);
   EXPECT_TRUE(cpp_side_connection.DidSucceed());
 }
 
 }  // namespace js
 }  // namespace mojo