Fix handling of unexpected cases in bit-flip test.

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 128 matching lines @@
   CheckMessagePipe(arg.message_handle().get().value());
 }
 
 void CheckSampleEchoArgsList(const js_to_cpp::EchoArgsList& list) {
   if (list.is_null())
     return;
   CheckSampleEchoArgs(list.item());
   CheckSampleEchoArgsList(list.next());
 }
 
+// More forgiving checks are needed in the face of potentially corrupt
+// messages. The values don't matter so long as all accesses are within
+// bounds.
 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 CheckCorruptedDataPipe(MojoHandle data_pipe_handle) {
+  unsigned char buffer[100];
+  uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
+  MojoResult result = MojoReadData(
+      data_pipe_handle, buffer, &buffer_size, MOJO_READ_DATA_FLAG_NONE);
+  if (result != MOJO_RESULT_OK)
+    return;
+  for (uint32_t i = 0; i < buffer_size; ++i)
+    g_waste_accumulator += buffer[i];
+}
+
+void CheckCorruptedMessagePipe(MojoHandle message_pipe_handle) {
+  unsigned char buffer[100];
+  uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
+  MojoResult result = MojoReadMessage(
+      message_pipe_handle, buffer, &buffer_size, 0, 0, 0);
+  if (result != MOJO_RESULT_OK)
+    return;
+  for (uint32_t i = 0; i < buffer_size; ++i)
+    g_waste_accumulator += buffer[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());
+    CheckCorruptedDataPipe(arg.data_handle().get().value());
   if (arg.message_handle().is_valid())
-    CheckMessagePipe(arg.message_handle().get().value());
+    CheckCorruptedMessagePipe(arg.message_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) {
+  CppSideConnection() :
+      run_loop_(NULL),
+      js_side_(NULL),
+      mishandled_messages_(0) {
   }
   virtual ~CppSideConnection() {}
 
   void set_run_loop(base::RunLoop* run_loop) { run_loop_ = run_loop; }
   base::RunLoop* run_loop() { return run_loop_; }
 
   void set_js_side(js_to_cpp::JsSide* js_side) { js_side_ = js_side; }
   js_to_cpp::JsSide* js_side() { return js_side_; }
 
   // js_to_cpp::CppSide:
   virtual void StartTest() OVERRIDE {
     NOTREACHED();
   }
 
   virtual void TestFinished() OVERRIDE {
     NOTREACHED();
   }
 
   virtual void PingResponse() OVERRIDE {
-    NOTREACHED();
+    mishandled_messages_ += 1;
   }
 
   virtual void EchoResponse(const js_to_cpp::EchoArgsList& list) OVERRIDE {
-    NOTREACHED();
+    mishandled_messages_ += 1;
   }
 
   virtual void BitFlipResponse(const js_to_cpp::EchoArgsList& list) OVERRIDE {
-    NOTREACHED();
+    mishandled_messages_ += 1;
   }
 
   virtual void BackPointerResponse(
       const js_to_cpp::EchoArgsList& list) OVERRIDE {
-    NOTREACHED();
+    mishandled_messages_ += 1;
   }
+
  protected:
   base::RunLoop* run_loop_;
   js_to_cpp::JsSide* js_side_;
+  int mishandled_messages_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CppSideConnection);
 };
 
 // Trivial test to verify a message sent from JS is received.
 class PingCppSideConnection : public CppSideConnection {
  public:
   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_;
+    return got_message_ && !mishandled_messages_;
   }
 
  private:
   bool got_message_;
   DISALLOW_COPY_AND_ASSIGN(PingCppSideConnection);
 };
 
 // Test that parameters are passed with correct values.
 class EchoCppSideConnection : public CppSideConnection {
  public:
@@ skipping 19 matching lines @@
     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;
+    return termination_seen_ &&
+        !mishandled_messages_ &&
+        message_count_ == kExpectedMessageCount;
   }
 
  private:
   static const int kExpectedMessageCount = 10;
   int message_count_;
   bool termination_seen_;
   DISALLOW_COPY_AND_ASSIGN(EchoCppSideConnection);
 };
 
 // Test that corrupted messages don't wreak havoc.
@@ skipping 125 matching lines @@
   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