Home | History | Annotate | Download | only in tests 
      1 // Copyright 2015 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include <stdint.h>
      6 
      7 #include "base/bind.h"
      8 #include "base/callback.h"
      9 #include "base/logging.h"
     10 #include "base/message_loop/message_loop.h"
     11 #include "base/run_loop.h"
     12 #include "build/build_config.h"
     13 #include "mojo/public/cpp/bindings/binding.h"
     14 #include "mojo/public/cpp/bindings/interface_ptr.h"
     15 #include "mojo/public/cpp/bindings/string.h"
     16 #include "mojo/public/cpp/system/message_pipe.h"
     17 #include "mojo/public/cpp/test_support/test_support.h"
     18 #include "mojo/public/interfaces/bindings/tests/sample_interfaces.mojom.h"
     19 #include "testing/gtest/include/gtest/gtest.h"
     20 
     21 ///////////////////////////////////////////////////////////////////////////////
     22 //
     23 // The tests in this file are designed to test the interaction between a
     24 // Callback and its associated Binding. If a Callback is deleted before
     25 // being used we DCHECK fail--unless the associated Binding has already
     26 // been closed or deleted. This contract must be explained to the Mojo
     27 // application developer. For example it is the developer's responsibility to
     28 // ensure that the Binding is destroyed before an unused Callback is destroyed.
     29 //
     30 ///////////////////////////////////////////////////////////////////////////////
     31 
     32 namespace mojo {
     33 namespace test {
     34 namespace {
     35 
     36 void SaveValue(int32_t* storage, const base::Closure& closure, int32_t value) {
     37   *storage = value;
     38   if (!closure.is_null())
     39     closure.Run();
     40 }
     41 
     42 base::Callback<void(int32_t)> BindValueSaver(int32_t* last_value_seen,
     43                                              const base::Closure& closure) {
     44   return base::Bind(&SaveValue, last_value_seen, closure);
     45 }
     46 
     47 // An implementation of sample::Provider used on the server side.
     48 // It only implements one of the methods: EchoInt().
     49 // All it does is save the values and Callbacks it sees.
     50 class InterfaceImpl : public sample::Provider {
     51  public:
     52   InterfaceImpl()
     53       : last_server_value_seen_(0),
     54         callback_saved_(new EchoIntCallback) {}
     55 
     56   ~InterfaceImpl() override {
     57     if (callback_saved_) {
     58       delete callback_saved_;
     59     }
     60   }
     61 
     62   // Run's the callback previously saved from the last invocation
     63   // of |EchoInt()|.
     64   bool RunCallback() {
     65     if (callback_saved_) {
     66       callback_saved_->Run(last_server_value_seen_);
     67       return true;
     68     }
     69     return false;
     70   }
     71 
     72   // Delete's the previously saved callback.
     73   void DeleteCallback() {
     74     delete callback_saved_;
     75     callback_saved_ = nullptr;
     76   }
     77 
     78   // sample::Provider implementation
     79 
     80   // Saves its two input values in member variables and does nothing else.
     81   void EchoInt(int32_t x, const EchoIntCallback& callback) override {
     82     last_server_value_seen_ = x;
     83     *callback_saved_ = callback;
     84     if (!closure_.is_null()) {
     85       closure_.Run();
     86       closure_.Reset();
     87     }
     88   }
     89 
     90   void EchoString(const std::string& a,
     91                   const EchoStringCallback& callback) override {
     92     CHECK(false) << "Not implemented.";
     93   }
     94 
     95   void EchoStrings(const std::string& a,
     96                    const std::string& b,
     97                    const EchoStringsCallback& callback) override {
     98     CHECK(false) << "Not implemented.";
     99   }
    100 
    101   void EchoMessagePipeHandle(
    102       ScopedMessagePipeHandle a,
    103       const EchoMessagePipeHandleCallback& callback) override {
    104     CHECK(false) << "Not implemented.";
    105   }
    106 
    107   void EchoEnum(sample::Enum a, const EchoEnumCallback& callback) override {
    108     CHECK(false) << "Not implemented.";
    109   }
    110 
    111   void resetLastServerValueSeen() { last_server_value_seen_ = 0; }
    112 
    113   int32_t last_server_value_seen() const { return last_server_value_seen_; }
    114 
    115   void set_closure(const base::Closure& closure) { closure_ = closure; }
    116 
    117  private:
    118   int32_t last_server_value_seen_;
    119   EchoIntCallback* callback_saved_;
    120   base::Closure closure_;
    121 };
    122 
    123 class BindingCallbackTest : public testing::Test {
    124  public:
    125   BindingCallbackTest() {}
    126   ~BindingCallbackTest() override {}
    127 
    128  protected:
    129   int32_t last_client_callback_value_seen_;
    130   sample::ProviderPtr interface_ptr_;
    131 
    132   void PumpMessages() { base::RunLoop().RunUntilIdle(); }
    133 
    134  private:
    135   base::MessageLoop loop_;
    136 };
    137 
    138 // Tests that the InterfacePtr and the Binding can communicate with each
    139 // other normally.
    140 TEST_F(BindingCallbackTest, Basic) {
    141   // Create the ServerImpl and the Binding.
    142   InterfaceImpl server_impl;
    143   Binding<sample::Provider> binding(&server_impl, GetProxy(&interface_ptr_));
    144 
    145   // Initialize the test values.
    146   server_impl.resetLastServerValueSeen();
    147   last_client_callback_value_seen_ = 0;
    148 
    149   // Invoke the Echo method.
    150   base::RunLoop run_loop, run_loop2;
    151   server_impl.set_closure(run_loop.QuitClosure());
    152   interface_ptr_->EchoInt(
    153       7,
    154       BindValueSaver(&last_client_callback_value_seen_,
    155                      run_loop2.QuitClosure()));
    156   run_loop.Run();
    157 
    158   // Check that server saw the correct value, but the client has not yet.
    159   EXPECT_EQ(7, server_impl.last_server_value_seen());
    160   EXPECT_EQ(0, last_client_callback_value_seen_);
    161 
    162   // Now run the Callback.
    163   server_impl.RunCallback();
    164   run_loop2.Run();
    165 
    166   // Check that the client has now seen the correct value.
    167   EXPECT_EQ(7, last_client_callback_value_seen_);
    168 
    169   // Initialize the test values again.
    170   server_impl.resetLastServerValueSeen();
    171   last_client_callback_value_seen_ = 0;
    172 
    173   // Invoke the Echo method again.
    174   base::RunLoop run_loop3, run_loop4;
    175   server_impl.set_closure(run_loop3.QuitClosure());
    176   interface_ptr_->EchoInt(
    177       13,
    178       BindValueSaver(&last_client_callback_value_seen_,
    179                      run_loop4.QuitClosure()));
    180   run_loop3.Run();
    181 
    182   // Check that server saw the correct value, but the client has not yet.
    183   EXPECT_EQ(13, server_impl.last_server_value_seen());
    184   EXPECT_EQ(0, last_client_callback_value_seen_);
    185 
    186   // Now run the Callback again.
    187   server_impl.RunCallback();
    188   run_loop4.Run();
    189 
    190   // Check that the client has now seen the correct value again.
    191   EXPECT_EQ(13, last_client_callback_value_seen_);
    192 }
    193 
    194 // Tests that running the Callback after the Binding has been deleted
    195 // results in a clean failure.
    196 TEST_F(BindingCallbackTest, DeleteBindingThenRunCallback) {
    197   // Create the ServerImpl.
    198   InterfaceImpl server_impl;
    199   base::RunLoop run_loop;
    200   {
    201     // Create the binding in an inner scope so it can be deleted first.
    202     Binding<sample::Provider> binding(&server_impl, GetProxy(&interface_ptr_));
    203     interface_ptr_.set_connection_error_handler(run_loop.QuitClosure());
    204 
    205     // Initialize the test values.
    206     server_impl.resetLastServerValueSeen();
    207     last_client_callback_value_seen_ = 0;
    208 
    209     // Invoke the Echo method.
    210     base::RunLoop run_loop2;
    211     server_impl.set_closure(run_loop2.QuitClosure());
    212     interface_ptr_->EchoInt(
    213         7,
    214         BindValueSaver(&last_client_callback_value_seen_, base::Closure()));
    215     run_loop2.Run();
    216   }
    217   // The binding has now been destroyed and the pipe is closed.
    218 
    219   // Check that server saw the correct value, but the client has not yet.
    220   EXPECT_EQ(7, server_impl.last_server_value_seen());
    221   EXPECT_EQ(0, last_client_callback_value_seen_);
    222 
    223   // Now try to run the Callback. This should do nothing since the pipe
    224   // is closed.
    225   EXPECT_TRUE(server_impl.RunCallback());
    226   PumpMessages();
    227 
    228   // Check that the client has still not seen the correct value.
    229   EXPECT_EQ(0, last_client_callback_value_seen_);
    230 
    231   // Attempt to invoke the method again and confirm that an error was
    232   // encountered.
    233   interface_ptr_->EchoInt(
    234       13,
    235       BindValueSaver(&last_client_callback_value_seen_, base::Closure()));
    236   run_loop.Run();
    237   EXPECT_TRUE(interface_ptr_.encountered_error());
    238 }
    239 
    240 // Tests that deleting a Callback without running it after the corresponding
    241 // binding has already been deleted does not result in a crash.
    242 TEST_F(BindingCallbackTest, DeleteBindingThenDeleteCallback) {
    243   // Create the ServerImpl.
    244   InterfaceImpl server_impl;
    245   {
    246     // Create the binding in an inner scope so it can be deleted first.
    247     Binding<sample::Provider> binding(&server_impl, GetProxy(&interface_ptr_));
    248 
    249     // Initialize the test values.
    250     server_impl.resetLastServerValueSeen();
    251     last_client_callback_value_seen_ = 0;
    252 
    253     // Invoke the Echo method.
    254     base::RunLoop run_loop;
    255     server_impl.set_closure(run_loop.QuitClosure());
    256     interface_ptr_->EchoInt(
    257         7,
    258         BindValueSaver(&last_client_callback_value_seen_, base::Closure()));
    259     run_loop.Run();
    260   }
    261   // The binding has now been destroyed and the pipe is closed.
    262 
    263   // Check that server saw the correct value, but the client has not yet.
    264   EXPECT_EQ(7, server_impl.last_server_value_seen());
    265   EXPECT_EQ(0, last_client_callback_value_seen_);
    266 
    267   // Delete the callback without running it. This should not
    268   // cause a problem because the insfrastructure can detect that the
    269   // binding has already been destroyed and the pipe is closed.
    270   server_impl.DeleteCallback();
    271 }
    272 
    273 // Tests that closing a Binding allows us to delete a callback
    274 // without running it without encountering a crash.
    275 TEST_F(BindingCallbackTest, CloseBindingBeforeDeletingCallback) {
    276   // Create the ServerImpl and the Binding.
    277   InterfaceImpl server_impl;
    278   Binding<sample::Provider> binding(&server_impl, GetProxy(&interface_ptr_));
    279 
    280   // Initialize the test values.
    281   server_impl.resetLastServerValueSeen();
    282   last_client_callback_value_seen_ = 0;
    283 
    284   // Invoke the Echo method.
    285   base::RunLoop run_loop;
    286   server_impl.set_closure(run_loop.QuitClosure());
    287   interface_ptr_->EchoInt(
    288       7,
    289       BindValueSaver(&last_client_callback_value_seen_, base::Closure()));
    290   run_loop.Run();
    291 
    292   // Check that server saw the correct value, but the client has not yet.
    293   EXPECT_EQ(7, server_impl.last_server_value_seen());
    294   EXPECT_EQ(0, last_client_callback_value_seen_);
    295 
    296   // Now close the Binding.
    297   binding.Close();
    298 
    299   // Delete the callback without running it. This should not
    300   // cause a crash because the insfrastructure can detect that the
    301   // binding has already been closed.
    302   server_impl.DeleteCallback();
    303 
    304   // Check that the client has still not seen the correct value.
    305   EXPECT_EQ(0, last_client_callback_value_seen_);
    306 }
    307 
    308 // Tests that deleting a Callback without using it before the
    309 // Binding has been destroyed or closed results in a DCHECK.
    310 TEST_F(BindingCallbackTest, DeleteCallbackBeforeBindingDeathTest) {
    311   // Create the ServerImpl and the Binding.
    312   InterfaceImpl server_impl;
    313   Binding<sample::Provider> binding(&server_impl, GetProxy(&interface_ptr_));
    314 
    315   // Initialize the test values.
    316   server_impl.resetLastServerValueSeen();
    317   last_client_callback_value_seen_ = 0;
    318 
    319   // Invoke the Echo method.
    320   base::RunLoop run_loop;
    321   server_impl.set_closure(run_loop.QuitClosure());
    322   interface_ptr_->EchoInt(
    323       7,
    324       BindValueSaver(&last_client_callback_value_seen_, base::Closure()));
    325   run_loop.Run();
    326 
    327   // Check that server saw the correct value, but the client has not yet.
    328   EXPECT_EQ(7, server_impl.last_server_value_seen());
    329   EXPECT_EQ(0, last_client_callback_value_seen_);
    330 
    331 #if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)) && !defined(OS_ANDROID)
    332   // Delete the callback without running it. This should cause a crash in debug
    333   // builds due to a DCHECK.
    334   std::string regex("Check failed: !is_valid");
    335 #if defined(OS_WIN)
    336   // TODO(msw): Fix MOJO_DCHECK logs and EXPECT_DEATH* on Win: crbug.com/535014
    337   regex.clear();
    338 #endif  // OS_WIN
    339   EXPECT_DEATH_IF_SUPPORTED(server_impl.DeleteCallback(), regex.c_str());
    340 #endif  // (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)) &&
    341         // !defined(OS_ANDROID)
    342 }
    343 
    344 }  // namespace
    345 }  // namespace test
    346 }  // namespace mojo
    347