Mojo: Add ErrorHandler to RemotePtr

mojo/public/bindings/tests/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/error_handler.h"
 #include "mojo/public/bindings/remote_ptr.h"
 #include "mojo/public/environment/environment.h"
 #include "mojo/public/utility/run_loop.h"
 #include "mojom/math_calculator.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_; }
+
+  virtual void OnError() MOJO_OVERRIDE {
+    encountered_error_ = true;
+  }
+
+ private:
+  bool encountered_error_;
+};
 
 class MathCalculatorImpl : public math::Calculator {
  public:
   virtual ~MathCalculatorImpl() {}
 
   explicit MathCalculatorImpl(ScopedMessagePipeHandle pipe)
       : ui_(pipe.Pass(), this),
         total_(0.0) {
   }
 
@@ skipping 11 matching lines @@
     ui_->Output(total_);
   }
 
  private:
   RemotePtr<math::CalculatorUI> ui_;
   double total_;
 };
 
 class MathCalculatorUIImpl : public math::CalculatorUI {
  public:
-  explicit MathCalculatorUIImpl(ScopedMessagePipeHandle pipe)
-      : calculator_(pipe.Pass(), this),
+  explicit MathCalculatorUIImpl(ScopedMessagePipeHandle pipe,
+                                ErrorHandler* error_handler = NULL)
+      : calculator_(pipe.Pass(), this, error_handler),
         output_(0.0) {
   }
 
   bool encountered_error() const {
     return calculator_.encountered_error();
   }
 
   void Add(double value) {
     calculator_->Add(value);
   }
@@ skipping 39 matching lines @@
 
  protected:
   ScopedMessagePipeHandle pipe0_;
   ScopedMessagePipeHandle pipe1_;
 
  private:
   Environment env_;
   RunLoop loop_;
 };
 
+}  // namespace
+
 TEST_F(RemotePtrTest, EndToEnd) {
   // Suppose this is instantiated in a process that has pipe0_.
   MathCalculatorImpl calculator(pipe0_.Pass());
 
   // Suppose this is instantiated in a process that has pipe1_.
   MathCalculatorUIImpl calculator_ui(pipe1_.Pass());
 
   calculator_ui.Add(2.0);
   calculator_ui.Multiply(5.0);
 
@@ skipping 52 matching lines @@
 
   // 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(RemotePtrTest, EncounteredErrorCallback) {
+  MathCalculatorImpl* calculator = new MathCalculatorImpl(pipe0_.Pass());
+
+  ErrorObserver error_observer;
+  MathCalculatorUIImpl calculator_ui(pipe1_.Pass(), &error_observer);
+
+  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 other side of the pipe.
+  delete calculator;
+
+  // 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());
+
+  // We should have also been able to observe the error through the
+  // ErrorHandler interface.
+  EXPECT_TRUE(error_observer.encountered_error());
+}
+
 }  // namespace test
 }  // namespace mojo