Declient calculator test mojom.

mojo/public/cpp/bindings/tests/interface_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 "base/bind.h"
+#include "base/callback.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/error_handler.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/public/cpp/environment/environment.h"
 #include "mojo/public/cpp/utility/run_loop.h"
 #include "mojo/public/interfaces/bindings/tests/math_calculator.mojom.h"
 #include "mojo/public/interfaces/bindings/tests/sample_service.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace test {
 namespace {
 
 class ErrorObserver : public ErrorHandler {
  public:
   ErrorObserver() : encountered_error_(false) {}
 
   bool encountered_error() const { return encountered_error_; }
 
   void OnConnectionError() override { encountered_error_ = true; }
 
  private:
   bool encountered_error_;
 };
 
+typedef mojo::Callback<void(double)> CalcCallback;
+
 class MathCalculatorImpl : public InterfaceImpl<math::Calculator> {

[jamesr, 2015/01/22 00:30:04]

if you're rewriting these anyway might as well switch from InterfaceImpl<> to
Binding<> as well

[Aaron Boodman, 2015/01/22 22:27:29]

It seems to work fine as InterfaceImpl. I'd rather contain the changes as much
as possible.

  public:
   ~MathCalculatorImpl() override {}
 
   MathCalculatorImpl() : total_(0.0) {}
 
-  void Clear() override { client()->Output(total_); }
-
-  void Add(double value) override {
-    total_ += value;
-    client()->Output(total_);
+  void Clear(const CalcCallback& callback) override {
+    // TODO(aa): Shouldn't it actually reset total_?

[jamesr, 2015/01/22 00:30:04]

instead of a TODO can you just do it? do the tests rely on it?

[Aaron Boodman, 2015/01/22 22:27:29]

Done.

+    callback.Run(total_);
   }
 
-  void Multiply(double value) override {
+  void Add(double value, const CalcCallback& callback) override {
+    total_ += value;
+    callback.Run(total_);
+  }
+
+  void Multiply(double value, const CalcCallback& callback) override {
     total_ *= value;
-    client()->Output(total_);
+    callback.Run(total_);
   }
 
  private:
   double total_;
 };
 
-class MathCalculatorUIImpl : public math::CalculatorUI {
+class MathCalculatorUI {
  public:
-  explicit MathCalculatorUIImpl(math::CalculatorPtr calculator)
-      : calculator_(calculator.Pass()), output_(0.0) {
-    calculator_.set_client(this);
-  }
+  explicit MathCalculatorUI(math::CalculatorPtr calculator)
+      : calculator_(calculator.Pass()),
+        callback_(
+            base::Bind(&MathCalculatorUI::Output, base::Unretained(this))),

[jamesr, 2015/01/22 00:30:04]

since there's only one type of Output it should be pretty trivial to create a
functor object and avoid all the base/ dependencies

[Aaron Boodman, 2015/01/22 22:27:29]

You keep using that word 'functor'. I don't think it means what you think it
means :). (It would be an class with a call operator, which won't help us here
AFAICT).

Anyway, we can make one-off classes with Run() methods that delegate back to the
parent class. But that seems so icky. Instead, I defined a helper that is at
least a little bit generally useful in callback.h. See what you think...

+        output_(0.0) {}
 
   bool WaitForIncomingMethodCall() {
     return calculator_.WaitForIncomingMethodCall();
   }
 
   bool encountered_error() const { return calculator_.encountered_error(); }
 
-  void Add(double value) { calculator_->Add(value); }
+  void Add(double value) { calculator_->Add(value, callback_); }
 
-  void Subtract(double value) { calculator_->Add(-value); }
+  void Subtract(double value) { calculator_->Add(-value, callback_); }
 
-  void Multiply(double value) { calculator_->Multiply(value); }
+  void Multiply(double value) { calculator_->Multiply(value, callback_); }
 
-  void Divide(double value) { calculator_->Multiply(1.0 / value); }
+  void Divide(double value) { calculator_->Multiply(1.0 / value, callback_); }
 
   double GetOutput() const { return output_; }
 
  private:
-  // math::CalculatorUI implementation:
-  void Output(double value) override { output_ = value; }
+  void Output(double value) { output_ = value; }
 
   math::CalculatorPtr calculator_;
+  mojo::Callback<void(double)> callback_;
   double output_;
 };
 
-class SelfDestructingMathCalculatorUIImpl : public math::CalculatorUI {
+class SelfDestructingMathCalculatorUI {
  public:
-  explicit SelfDestructingMathCalculatorUIImpl(math::CalculatorPtr calculator)
-      : calculator_(calculator.Pass()), nesting_level_(0) {
+  explicit SelfDestructingMathCalculatorUI(math::CalculatorPtr calculator)
+      : calculator_(calculator.Pass()),
+        callback_(base::Bind(&SelfDestructingMathCalculatorUI::Output,
+                             base::Unretained(this))),
+        nesting_level_(0) {
     ++num_instances_;
-    calculator_.set_client(this);
   }
 
   void BeginTest(bool nested) {
     nesting_level_ = nested ? 2 : 1;
-    calculator_->Add(1.0);
+    calculator_->Add(1.0, callback_);
   }
 
   static int num_instances() { return num_instances_; }
 
  private:
-  ~SelfDestructingMathCalculatorUIImpl() override { --num_instances_; }
+  ~SelfDestructingMathCalculatorUI() { --num_instances_; }
 
-  void Output(double value) override {
+  void Output(double value) {
     if (--nesting_level_ > 0) {
       // Add some more and wait for re-entrant call to Output!
-      calculator_->Add(1.0);
+      calculator_->Add(1.0, callback_);
       RunLoop::current()->RunUntilIdle();
     } else {
       delete this;
     }
   }
 
   math::CalculatorPtr calculator_;
+  mojo::Callback<void(double)> callback_;
   int nesting_level_;
   static int num_instances_;
 };
 
 // static
-int SelfDestructingMathCalculatorUIImpl::num_instances_ = 0;
+int SelfDestructingMathCalculatorUI::num_instances_ = 0;
 
 class ReentrantServiceImpl : public InterfaceImpl<sample::Service> {
  public:
   ~ReentrantServiceImpl() override {}
 
   ReentrantServiceImpl() : call_depth_(0), max_call_depth_(0) {}
 
   int max_call_depth() { return max_call_depth_; }
 
   void Frobinate(sample::FooPtr foo,
@@ skipping 22 matching lines @@
  private:
   Environment env_;
   RunLoop loop_;
 };
 
 TEST_F(InterfacePtrTest, EndToEnd) {
   math::CalculatorPtr calc;
   BindToProxy(new MathCalculatorImpl(), &calc);
 
   // Suppose this is instantiated in a process that has pipe1_.
-  MathCalculatorUIImpl calculator_ui(calc.Pass());
+  MathCalculatorUI calculator_ui(calc.Pass());
 
   calculator_ui.Add(2.0);
   calculator_ui.Multiply(5.0);
 
   PumpMessages();
 
   EXPECT_EQ(10.0, calculator_ui.GetOutput());
 }
 
 TEST_F(InterfacePtrTest, EndToEnd_Synchronous) {
   math::CalculatorPtr calc;
   MathCalculatorImpl* impl = BindToProxy(new MathCalculatorImpl(), &calc);
 
   // Suppose this is instantiated in a process that has pipe1_.
-  MathCalculatorUIImpl calculator_ui(calc.Pass());
+  MathCalculatorUI calculator_ui(calc.Pass());
 
   EXPECT_EQ(0.0, calculator_ui.GetOutput());
 
   calculator_ui.Add(2.0);
   EXPECT_EQ(0.0, calculator_ui.GetOutput());
   impl->WaitForIncomingMethodCall();
   calculator_ui.WaitForIncomingMethodCall();
   EXPECT_EQ(2.0, calculator_ui.GetOutput());
 
   calculator_ui.Multiply(5.0);
@@ skipping 37 matching lines @@
   EXPECT_FALSE(a.internal_state()->router_for_testing());
 
   // Test that handle was closed.
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, CloseRaw(handle));
 }
 
 TEST_F(InterfacePtrTest, EncounteredError) {
   math::CalculatorPtr proxy;
   MathCalculatorImpl* server = BindToProxy(new MathCalculatorImpl(), &proxy);
 
-  MathCalculatorUIImpl calculator_ui(proxy.Pass());
+  MathCalculatorUI calculator_ui(proxy.Pass());
 
   calculator_ui.Add(2.0);
   PumpMessages();
   EXPECT_EQ(2.0, calculator_ui.GetOutput());
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   calculator_ui.Multiply(5.0);
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   // Close the server.
   server->internal_router()->CloseMessagePipe();
 
   // The state change isn't picked up locally yet.
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   PumpMessages();
 
   // OK, now we see the error.
   EXPECT_TRUE(calculator_ui.encountered_error());
 }
 
 TEST_F(InterfacePtrTest, EncounteredErrorCallback) {
   math::CalculatorPtr proxy;
   MathCalculatorImpl* server = BindToProxy(new MathCalculatorImpl(), &proxy);
 
   ErrorObserver error_observer;
   proxy.set_error_handler(&error_observer);
 
-  MathCalculatorUIImpl calculator_ui(proxy.Pass());
+  MathCalculatorUI calculator_ui(proxy.Pass());
 
   calculator_ui.Add(2.0);
   PumpMessages();
   EXPECT_EQ(2.0, calculator_ui.GetOutput());
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   calculator_ui.Multiply(5.0);
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   // Close the server.
@@ skipping 17 matching lines @@
   // does not have an explicit Client attribute.
   sample::PortPtr port;
   MessagePipe pipe;
   port.Bind(pipe.handle0.Pass());
 }
 
 TEST_F(InterfacePtrTest, DestroyInterfacePtrOnClientMethod) {
   math::CalculatorPtr proxy;
   BindToProxy(new MathCalculatorImpl(), &proxy);
 
-  EXPECT_EQ(0, SelfDestructingMathCalculatorUIImpl::num_instances());
+  EXPECT_EQ(0, SelfDestructingMathCalculatorUI::num_instances());
 
-  SelfDestructingMathCalculatorUIImpl* impl =
-      new SelfDestructingMathCalculatorUIImpl(proxy.Pass());
+  SelfDestructingMathCalculatorUI* impl =
+      new SelfDestructingMathCalculatorUI(proxy.Pass());
   impl->BeginTest(false);
 
   PumpMessages();
 
-  EXPECT_EQ(0, SelfDestructingMathCalculatorUIImpl::num_instances());
+  EXPECT_EQ(0, SelfDestructingMathCalculatorUI::num_instances());
 }
 
 TEST_F(InterfacePtrTest, NestedDestroyInterfacePtrOnClientMethod) {
   math::CalculatorPtr proxy;
   BindToProxy(new MathCalculatorImpl(), &proxy);
 
-  EXPECT_EQ(0, SelfDestructingMathCalculatorUIImpl::num_instances());
+  EXPECT_EQ(0, SelfDestructingMathCalculatorUI::num_instances());
 
-  SelfDestructingMathCalculatorUIImpl* impl =
-      new SelfDestructingMathCalculatorUIImpl(proxy.Pass());
+  SelfDestructingMathCalculatorUI* impl =
+      new SelfDestructingMathCalculatorUI(proxy.Pass());
   impl->BeginTest(true);
 
   PumpMessages();
 
-  EXPECT_EQ(0, SelfDestructingMathCalculatorUIImpl::num_instances());
+  EXPECT_EQ(0, SelfDestructingMathCalculatorUI::num_instances());
 }
 
 TEST_F(InterfacePtrTest, ReentrantWaitForIncomingMethodCall) {
   sample::ServicePtr proxy;
   ReentrantServiceImpl* impl = BindToProxy(new ReentrantServiceImpl(), &proxy);
 
   proxy->Frobinate(nullptr, sample::Service::BAZ_OPTIONS_REGULAR, nullptr);
   proxy->Frobinate(nullptr, sample::Service::BAZ_OPTIONS_REGULAR, nullptr);
 
   PumpMessages();
 
   EXPECT_EQ(2, impl->max_call_depth());
 }
 
 class StrongMathCalculatorImpl : public math::Calculator, public ErrorHandler {
  public:
+  typedef mojo::Callback<void(double)> Callback;

[jamesr, 2015/01/22 00:30:04]

I think we already have this typedef

[Aaron Boodman, 2015/01/22 22:27:29]

Done.

+
   StrongMathCalculatorImpl(ScopedMessagePipeHandle handle,
                            bool* error_received,
                            bool* destroyed)
       : error_received_(error_received),
         destroyed_(destroyed),
         binding_(this, handle.Pass()) {
     binding_.set_error_handler(this);
   }
   ~StrongMathCalculatorImpl() override { *destroyed_ = true; }
 
   // math::Calculator implementation.
-  void Clear() override { binding_.client()->Output(total_); }
+  void Clear(const CalcCallback& callback) override { callback.Run(total_); }
 
-  void Add(double value) override {
+  void Add(double value, const CalcCallback& callback) override {
     total_ += value;
-    binding_.client()->Output(total_);
+    callback.Run(total_);
   }
 
-  void Multiply(double value) override {
+  void Multiply(double value, const CalcCallback& callback) override {
     total_ *= value;
-    binding_.client()->Output(total_);
+    callback.Run(total_);
   }
 
   // ErrorHandler implementation.
   void OnConnectionError() override { *error_received_ = true; }
 
  private:
   double total_ = 0.0;
   bool* error_received_;
   bool* destroyed_;
 
   StrongBinding<math::Calculator> binding_;
 };
 
 TEST(StrongConnectorTest, Math) {
   Environment env;
   RunLoop loop;
 
   bool error_received = false;
   bool destroyed = false;
   MessagePipe pipe;
   new StrongMathCalculatorImpl(pipe.handle0.Pass(), &error_received,
                                &destroyed);
 
   math::CalculatorPtr calc;
   calc.Bind(pipe.handle1.Pass());
 
   {
     // Suppose this is instantiated in a process that has the other end of the
     // message pipe.
-    MathCalculatorUIImpl calculator_ui(calc.Pass());
+    MathCalculatorUI calculator_ui(calc.Pass());
 
     calculator_ui.Add(2.0);
     calculator_ui.Multiply(5.0);
 
     loop.RunUntilIdle();
 
     EXPECT_EQ(10.0, calculator_ui.GetOutput());
     EXPECT_FALSE(error_received);
     EXPECT_FALSE(destroyed);
   }
@@ skipping 11 matching lines @@
   WeakMathCalculatorImpl(ScopedMessagePipeHandle handle,
                          bool* error_received,
                          bool* destroyed)
       : error_received_(error_received),
         destroyed_(destroyed),
         binding_(this, handle.Pass()) {
     binding_.set_error_handler(this);
   }
   ~WeakMathCalculatorImpl() override { *destroyed_ = true; }
 
-  void Clear() override { binding_.client()->Output(total_); }
+  void Clear(const CalcCallback& callback) override { callback.Run(total_); }
 
-  void Add(double value) override {
+  void Add(double value, const CalcCallback& callback) override {
     total_ += value;
-    binding_.client()->Output(total_);
+    callback.Run(total_);
   }
 
-  void Multiply(double value) override {
+  void Multiply(double value, const CalcCallback& callback) override {
     total_ *= value;
-    binding_.client()->Output(total_);
+    callback.Run(total_);
   }
 
   // ErrorHandler implementation.
   void OnConnectionError() override { *error_received_ = true; }
 
  private:
   double total_ = 0.0;
   bool* error_received_;
   bool* destroyed_;
 
   Binding<math::Calculator> binding_;
 };
 
 TEST(WeakConnectorTest, Math) {
   Environment env;
   RunLoop loop;
 
   bool error_received = false;
   bool destroyed = false;
   MessagePipe pipe;
   WeakMathCalculatorImpl impl(pipe.handle0.Pass(), &error_received, &destroyed);
 
   math::CalculatorPtr calc;
   calc.Bind(pipe.handle1.Pass());
 
   {
     // Suppose this is instantiated in a process that has the other end of the
     // message pipe.
-    MathCalculatorUIImpl calculator_ui(calc.Pass());
+    MathCalculatorUI calculator_ui(calc.Pass());
 
     calculator_ui.Add(2.0);
     calculator_ui.Multiply(5.0);
 
     loop.RunUntilIdle();
 
     EXPECT_EQ(10.0, calculator_ui.GetOutput());
     EXPECT_FALSE(error_received);
     EXPECT_FALSE(destroyed);
     // Destroying calculator_ui should close the pipe and generate an error on
     // the other
     // end which will destroy the instance since it is strongly bound.
   }
 
   loop.RunUntilIdle();
   EXPECT_TRUE(error_received);
   EXPECT_FALSE(destroyed);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo