Mojo: abstract interface implementation from generated Stub classes

mojo/public/tests/bindings_remote_ptr_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/bindings/lib/remote_ptr.h"
 #include "mojo/public/tests/simple_bindings_support.h"
 #include "mojom/math_calculator.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace test {
 
-class MathCalculatorImpl : public math::CalculatorStub {
+class MathCalculatorImpl : public math::Calculator {
  public:
   virtual ~MathCalculatorImpl() {}
 
   explicit MathCalculatorImpl(ScopedMessagePipeHandle pipe)
-      : ui_(pipe.Pass()),
+      : ui_(pipe.Pass(), this),
         total_(0.0) {
-    ui_.SetPeer(this);
   }
 
   virtual void Clear() MOJO_OVERRIDE {
     ui_->Output(total_);
   }
 
   virtual void Add(double value) MOJO_OVERRIDE {
     total_ += value;
     ui_->Output(total_);
   }
 
   virtual void Multiply(double value) MOJO_OVERRIDE {
     total_ *= value;
     ui_->Output(total_);
   }
 
  private:
   RemotePtr<math::CalculatorUI> ui_;
   double total_;
 };
 
-class MathCalculatorUIImpl : public math::CalculatorUIStub {
+class MathCalculatorUIImpl : public math::CalculatorUI {
  public:
   explicit MathCalculatorUIImpl(ScopedMessagePipeHandle pipe)
-      : calculator_(pipe.Pass()),
+      : calculator_(pipe.Pass(), this),
         output_(0.0) {
-    calculator_.SetPeer(this);
   }
 
   bool encountered_error() const {
     return calculator_.encountered_error();
   }
 
   void Add(double value) {
     calculator_->Add(value);
   }
 
@@ skipping 54 matching lines @@
   calculator_ui.Add(2.0);
   calculator_ui.Multiply(5.0);
 
   PumpMessages();
 
   EXPECT_EQ(10.0, calculator_ui.GetOutput());
 }
 
 TEST_F(BindingsRemotePtrTest, Movable) {
   RemotePtr<math::Calculator> a;
-  RemotePtr<math::Calculator> b(pipe0_.Pass());
+  RemotePtr<math::Calculator> b(pipe0_.Pass(), NULL);
 
   EXPECT_TRUE(a.is_null());
   EXPECT_FALSE(b.is_null());
 
   a = b.Pass();
 
   EXPECT_FALSE(a.is_null());
   EXPECT_TRUE(b.is_null());
 }
 
 TEST_F(BindingsRemotePtrTest, Resettable) {
   RemotePtr<math::Calculator> a;
 
   EXPECT_TRUE(a.is_null());
 
   MessagePipeHandle handle = pipe0_.get();
 
-  a.reset(pipe0_.Pass());
+  a.reset(pipe0_.Pass(), NULL);
 
   EXPECT_FALSE(a.is_null());
 
   a.reset();
 
   EXPECT_TRUE(a.is_null());
 
   // Test that handle was closed.
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, CloseRaw(handle));
 }
@@ skipping 18 matching lines @@
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   PumpMessages();
 
   // OK, now we see the error.
   EXPECT_TRUE(calculator_ui.encountered_error());
 }
 
 }  // namespace test
 }  // namespace mojo