Mojo C++ Bindings: Introduce mojo::SupportsStrongBinding

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 <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 462 matching lines @@
   EXPECT_EQ(4u, ptr.version());
   base::RunLoop run_loop3;
   ptr.set_connection_error_handler(run_loop3.QuitClosure());
   ptr->SetInteger(789, sample::Enum::VALUE);
   run_loop3.Run();
   EXPECT_TRUE(ptr.encountered_error());
   // The call to SetInteger() after RequireVersion(4u) is ignored.
   EXPECT_EQ(456, impl.integer());
 }
 
-class StrongMathCalculatorImpl : public math::Calculator {
+class StrongMathCalculatorImpl
+    : public SupportsStrongBinding<math::Calculator> {
  public:
   StrongMathCalculatorImpl(bool* destroyed) : destroyed_(destroyed) {}
   ~StrongMathCalculatorImpl() override { *destroyed_ = true; }
 
   // math::Calculator implementation.
   void Clear(const CalcCallback& callback) override { callback.Run(total_); }
 
   void Add(double value, const CalcCallback& callback) override {
     total_ += value;
     callback.Run(total_);
@@ skipping 112 matching lines @@
     // 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.
   }
 
   run_loop.Run();
   EXPECT_TRUE(error_received);
   EXPECT_FALSE(destroyed);
 }
 
-class CImpl : public C {
+class CImpl : public SupportsStrongBinding<C> {
  public:
   CImpl(bool* d_called, const base::Closure& closure)
       : d_called_(d_called), closure_(closure) {}
   ~CImpl() override {}
 
  private:
   void D() override {
     *d_called_ = true;
     closure_.Run();
   }
 
   bool* d_called_;
   base::Closure closure_;
 };
 
-class BImpl : public B {
+class BImpl : public SupportsStrongBinding<B> {
  public:
   BImpl(bool* d_called, const base::Closure& closure)
       : d_called_(d_called), closure_(closure) {}
   ~BImpl() override {}
 
  private:
   void GetC(InterfaceRequest<C> c) override {
     MakeStrongBinding(base::MakeUnique<CImpl>(d_called_, closure_),
                       std::move(c));
   }
@@ skipping 204 matching lines @@
       thread_safe_ptr);
   other_thread.message_loop()->task_runner()->PostTask(FROM_HERE, run_method);
 
   // Block until the method callback is called on the background thread.
   run_loop.Run();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo