Add mojo bindings backpointer tests.

mojo/apps/js/test/js_to_cpp_unittest.cc

 // 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.
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "gin/public/isolate_holder.h"
@@ skipping 108 matching lines @@
   EXPECT_EQ(kExpectedDoubleVal, arg.double_val());
   EXPECT_EQ(kExpectedDoubleInf, arg.double_inf());
   EXPECT_NAN(arg.double_nan());
   EXPECT_EQ(std::string("coming"), arg.name().To<std::string>());
   EXPECT_EQ(std::string("one"), arg.string_array()[0].To<std::string>());
   EXPECT_EQ(std::string("two"), arg.string_array()[1].To<std::string>());
   EXPECT_EQ(std::string("three"), arg.string_array()[2].To<std::string>());
   CheckDataPipe(arg.data_handle().get().value());
 }
 
-js_to_cpp::EchoArgsList BuildSampleEchoArgsList() {
-  js_to_cpp::EchoArgsList::Builder builder;
-  builder.set_item(BuildSampleEchoArgs());
-  return builder.Finish();
-}
-
 void CheckSampleEchoArgsList(const js_to_cpp::EchoArgsList& list) {
   if (list.is_null())
     return;
   CheckSampleEchoArgs(list.item());
   CheckSampleEchoArgsList(list.next());
 }
 
 void CheckCorruptedString(const mojo::String& arg) {
   // The values don't matter so long as all accesses are within bounds.
   if (arg.is_null())
     return;
   for (size_t i = 0; i < arg.size(); ++i)
     g_waste_accumulator += arg[i];
 }
 
 void CheckCorruptedStringArray(const mojo::Array<mojo::String>& string_array) {
   if (string_array.is_null())
     return;
   for (size_t i = 0; i < string_array.size(); ++i)
     CheckCorruptedString(string_array[i]);
 }
 
+void CheckCorruptedEchoArgs(const js_to_cpp::EchoArgs& arg) {
+  if (arg.is_null())
+    return;
+  CheckCorruptedString(arg.name());
+  CheckCorruptedStringArray(arg.string_array());
+  if (arg.data_handle().is_valid())
+    CheckDataPipe(arg.data_handle().get().value());
+}
+
+void CheckCorruptedEchoArgsList(const js_to_cpp::EchoArgsList& list) {
+  if (list.is_null())
+    return;
+  CheckCorruptedEchoArgs(list.item());
+  CheckCorruptedEchoArgsList(list.next());
+}
+
 // Base Provider implementation class. It's expected that tests subclass and
 // override the appropriate Provider functions. When test is done quit the
 // run_loop().
 class CppSideConnection : public js_to_cpp::CppSide {
  public:
   CppSideConnection() : run_loop_(NULL), js_side_(NULL) {
   }
   virtual ~CppSideConnection() {}
 
   void set_run_loop(base::RunLoop* run_loop) { run_loop_ = run_loop; }
@@ skipping 12 matching lines @@
   }
 
   virtual void PingResponse() OVERRIDE {
     NOTREACHED();
   }
 
   virtual void EchoResponse(const js_to_cpp::EchoArgsList& list) OVERRIDE {
     NOTREACHED();
   }
 
-  virtual void BitFlipResponse(const js_to_cpp::EchoArgs& arg1) OVERRIDE {
+  virtual void BitFlipResponse(const js_to_cpp::EchoArgsList& list) OVERRIDE {
     NOTREACHED();
   }
 
+  virtual void BackPointerResponse(
+      const js_to_cpp::EchoArgsList& list) OVERRIDE {
+    NOTREACHED();
+  }
  protected:
   base::RunLoop* run_loop_;
   js_to_cpp::JsSide* js_side_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CppSideConnection);
 };
 
 // Trivial test to verify a message sent from JS is received.
 class PingCppSideConnection : public CppSideConnection {
  public:
-  explicit PingCppSideConnection() : got_message_(false) {}
+  PingCppSideConnection() : got_message_(false) {}
   virtual ~PingCppSideConnection() {}
 
   // js_to_cpp::CppSide:
   virtual void StartTest() OVERRIDE {
     js_side_->Ping();
   }
 
   virtual void PingResponse() OVERRIDE {
     got_message_ = true;
     run_loop()->Quit();
   }
 
   bool DidSucceed() {
     return got_message_;
   }
 
  private:
   bool got_message_;
   DISALLOW_COPY_AND_ASSIGN(PingCppSideConnection);
 };
 
 // Test that parameters are passed with correct values.
 class EchoCppSideConnection : public CppSideConnection {
  public:
-  explicit EchoCppSideConnection() :
+  EchoCppSideConnection() :
       message_count_(0),
       termination_seen_(false) {
   }
   virtual ~EchoCppSideConnection() {}
 
   // js_to_cpp::CppSide:
   virtual void StartTest() OVERRIDE {
     AllocationScope scope;
-    js_side_->Echo(kExpectedMessageCount, BuildSampleEchoArgsList());
+    js_side_->Echo(kExpectedMessageCount, BuildSampleEchoArgs());
   }
 
   virtual void EchoResponse(const js_to_cpp::EchoArgsList& list) OVERRIDE {
     const js_to_cpp::EchoArgs& special_arg = list.item();
     message_count_ += 1;
     EXPECT_EQ(-1, special_arg.si64());
     EXPECT_EQ(-1, special_arg.si32());
     EXPECT_EQ(-1, special_arg.si16());
     EXPECT_EQ(-1, special_arg.si8());
     EXPECT_EQ(std::string("going"), special_arg.name().To<std::string>());
     CheckSampleEchoArgsList(list.next());
   }
 
   virtual void TestFinished() OVERRIDE {
     termination_seen_ = true;
     run_loop()->Quit();
   }
 
   bool DidSucceed() {
     return termination_seen_ && message_count_ == kExpectedMessageCount;
   }
 
  private:
-  static const int kExpectedMessageCount = 100;
+  static const int kExpectedMessageCount = 10;
   int message_count_;
   bool termination_seen_;
   DISALLOW_COPY_AND_ASSIGN(EchoCppSideConnection);
 };
 
 // Test that corrupted messages don't wreak havoc.
 class BitFlipCppSideConnection : public CppSideConnection {
  public:
-  explicit BitFlipCppSideConnection() : termination_seen_(false) {}
+  BitFlipCppSideConnection() : termination_seen_(false) {}
   virtual ~BitFlipCppSideConnection() {}
 
   // js_to_cpp::CppSide:
   virtual void StartTest() OVERRIDE {
     AllocationScope scope;
     js_side_->BitFlip(BuildSampleEchoArgs());
   }
 
-  virtual void BitFlipResponse(const js_to_cpp::EchoArgs& arg) OVERRIDE {
-    if (arg.is_null())
-      return;
-    CheckCorruptedString(arg.name());
-    CheckCorruptedStringArray(arg.string_array());
-    if (arg.data_handle().is_valid())
-      CheckDataPipe(arg.data_handle().get().value());
+  virtual void BitFlipResponse(const js_to_cpp::EchoArgsList& list) OVERRIDE {
+    CheckCorruptedEchoArgsList(list);
   }
 
   virtual void TestFinished() OVERRIDE {
     termination_seen_ = true;
     run_loop()->Quit();
   }
 
   bool DidSucceed() {
     return termination_seen_;
   }
 
  private:
   bool termination_seen_;
   DISALLOW_COPY_AND_ASSIGN(BitFlipCppSideConnection);
 };
 
+// Test that severely random messages don't wreak havoc.
+class BackPointerCppSideConnection : public CppSideConnection {
+ public:
+  BackPointerCppSideConnection() : termination_seen_(false) {}
+  virtual ~BackPointerCppSideConnection() {}
+
+  // js_to_cpp::CppSide:
+  virtual void StartTest() OVERRIDE {
+    AllocationScope scope;
+    js_side_->BackPointer(BuildSampleEchoArgs());
+  }
+
+  virtual void BackPointerResponse(
+      const js_to_cpp::EchoArgsList& list) OVERRIDE {
+    CheckCorruptedEchoArgsList(list);
+  }
+
+  virtual void TestFinished() OVERRIDE {
+    termination_seen_ = true;
+    run_loop()->Quit();
+  }
+
+  bool DidSucceed() {
+    return termination_seen_;
+  }
+
+ private:
+  bool termination_seen_;
+  DISALLOW_COPY_AND_ASSIGN(BackPointerCppSideConnection);
+};
+
 }  // namespace
 
 class JsToCppTest : public testing::Test {
  public:
   JsToCppTest() {}
 
   void RunTest(const std::string& test, CppSideConnection* cpp_side) {
     cpp_side->set_run_loop(&run_loop_);
 
     MessagePipe pipe;
@@ skipping 43 matching lines @@
 // TODO(tsepez): Disabled due to http://crbug.com/366797.
 TEST_F(JsToCppTest, DISABLED_BitFlip) {
   if (IsRunningOnIsolatedBot())
     return;
 
   BitFlipCppSideConnection cpp_side_connection;
   RunTest("mojo/apps/js/test/js_to_cpp_unittest", &cpp_side_connection);
   EXPECT_TRUE(cpp_side_connection.DidSucceed());
 }
 
+// TODO(tsepez): Disabled due to http://crbug.com/366797.
+TEST_F(JsToCppTest, DISABLED_BackPointer) {
+  if (IsRunningOnIsolatedBot())
+    return;
+
+  BackPointerCppSideConnection cpp_side_connection;
+  RunTest("mojo/apps/js/test/js_to_cpp_unittest", &cpp_side_connection);
+  EXPECT_TRUE(cpp_side_connection.DidSucceed());
+}
+
 }  // namespace js
 }  // namespace mojo