Reporting of policy errors via host-offline-reason: part 3

remoting/host/mock_callback.h

 // 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.
 
 #ifndef REMOTING_HOST_MOCK_CALLBACK_H_
 #define REMOTING_HOST_MOCK_CALLBACK_H_
 
 // TODO(lukasza): If possible, move this header file to base/mock_callback.h
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
+#include "base/memory/ref_counted.h"
 
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace remoting {
 
+// MockCallback<Sig> can be used to mock Callback<Sig> from base/callback.h

[Lambros, 2014/12/03 03:20:25]

This basically looks fine, though I can't say I fully understand it all. My only
concern is the amount of code-duplication between the 0-parameter and
1-parameter versions of these classes.

+//
+// Basic usage example:
+//
+//   MockCallback<void(int)> mock_callback;
+//   EXPECT_CALL(mock_callback, Run(123)).Times(2);
+//   base::Callback<void(int)> callback = mock_callback.GetCallback();
+//
+//   // Use |callback| in the remainder of the test.
+//   // GMock will enforce the expectations from above.
+//
+// HasRemainingCallbacks usage example:
+//
+//   MockCallback<int()> mock_callback;
+//   EXPECT_CALL(mock_callback, Run()).WillOnce(Return(123));
+//   HypotheticalFunctionUnderTest(mock_callback.GetCallback());
+//   EXPECT_FALSE(mock_callback.HasRemainingCallbacks())
+//      << "Verify that FunctionUnderTest didn't store the callback "

[Lambros, 2014/12/03 03:20:25]

This feels like it should be a code comment, not a log message.

[Łukasz Anforowicz, 2014/12/03 17:54:22]

Maybe.  I think that having this message in the output of a failing test will
help.  I'll leave it in, unless you strongly object to this.

+//      << "and therefore callers of FunctionUnderTest don't have to "
+//      << "worry about lifetime of arguments bound to the callback";
+
 template <typename Sig>
 class MockCallback;
 
 template <typename R>
 class MockCallback<R()> {
  public:
   MOCK_CONST_METHOD0_T(Run, R());
 
-  MockCallback() {
+  MockCallback() : mock_callback_tracker_(new MockCallbackTracker(this)) {
   }
 
   // Caller of GetCallback has to guarantee that the returned callback
   // will not be run after |this| is destroyed.
   base::Callback<R()> GetCallback() {
-    return base::Bind(&MockCallback<R()>::Run, base::Unretained(this));
+    return base::Bind(&MockCallbackTracker::Run, mock_callback_tracker_);
+  }
+
+  // Returns |true| if callbacks returned by |GetCallback| have not been
+  // destroyed yet.
+  bool HasRemainingCallbacks() const {
+    bool is_tracker_field_the_only_ref = mock_callback_tracker_->HasOneRef();
+    return !is_tracker_field_the_only_ref;
   }
 
  private:
+  // MockCallbackTracker has 2 goals:
+  // - Enable counting of callbacks for |HasRemainingCallbacks| method.
+  // - Allow stack-allocated MockCallbacks to be short-lived, while
+  //   callbacks go through a long-lived MockCallbackTracker
+  //   (which in the future can enable better handling of callback-
+  //    -run-after-mock-callback-already-destroyed).
+  class MockCallbackTracker
+      : public base::RefCountedThreadSafe<MockCallbackTracker> {
+   public:
+    MockCallbackTracker(MockCallback* mock_callback)
+        : mock_callback_(mock_callback) {
+    }
+
+    R Run() {
+      // Forward to (gMock controlled) MockCallback::Run method.
+      return mock_callback_->Run();
+    }
+
+   private:
+    // Ref-counting helpers.
+    friend class base::RefCountedThreadSafe<MockCallbackTracker>;
+    ~MockCallbackTracker() {
+    }
+
+    MockCallback<R()>* mock_callback_;
+  };
+
+  scoped_refptr<MockCallbackTracker> mock_callback_tracker_;
+
   DISALLOW_COPY_AND_ASSIGN(MockCallback);
 };
 
+template <typename R, typename A1>
+class MockCallback<R(A1)> {
+ public:
+  MOCK_CONST_METHOD1_T(Run, R(A1));
+
+  MockCallback() : mock_callback_tracker_(new MockCallbackTracker(this)) {
+  }
+
+  // Caller of GetCallback has to guarantee that the returned callback
+  // will not be run after |this| is destroyed.
+  base::Callback<R(A1)> GetCallback() {
+    return base::Bind(&MockCallbackTracker::Run, mock_callback_tracker_);
+  }
+
+  // Returns |true| if callbacks returned by |GetCallback| have not been
+  // destroyed yet.
+  bool HasRemainingCallbacks() const {
+    bool is_tracker_field_the_only_ref = mock_callback_tracker_->HasOneRef();
+    return !is_tracker_field_the_only_ref;
+  }
+
+ private:
+  // MockCallbackTracker has 2 goals:
+  // - Enable counting of callbacks for |HasRemainingCallbacks| method.
+  // - Allow stack-allocated MockCallbacks to be short-lived, while
+  //   callbacks go through a long-lived MockCallbackTracker
+  //   (which in the future can enable better handling of callback-
+  //    -run-after-mock-callback-already-destroyed).
+  class MockCallbackTracker
+      : public base::RefCountedThreadSafe<MockCallbackTracker> {
+   public:
+    MockCallbackTracker(MockCallback* mock_callback)
+        : mock_callback_(mock_callback) {
+    }
+
+    R Run(A1 a1) {
+      // Forward to (gMock controlled) MockCallback::Run method.
+      return mock_callback_->Run(a1);
+    }
+
+   private:
+    // Ref-counting helpers.
+    friend class base::RefCountedThreadSafe<MockCallbackTracker>;
+    ~MockCallbackTracker() {
+    }
+
+    MockCallback<R(A1)>* mock_callback_;
+  };
+
+  scoped_refptr<MockCallbackTracker> mock_callback_tracker_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockCallback);
+};
+
 typedef MockCallback<void(void)> MockClosure;
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_MOCK_CALLBACK_H_