dbus: Fix a subtle butterfly-effect bug in handling incoming messages

dbus/end_to_end_async_unittest.cc

 // Copyright (c) 2012 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 <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "dbus/test_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace {
+
+// See comments in ObjectProxy::RunResponseCallback() for why the number was
+// chosen.
+const int kHugePayloadSize = 64 << 20;  // 64 MB
+
+}  // namespace
+
 // The end-to-end test exercises the asynchronous APIs in ObjectProxy and
 // ExportedObject.
 class EndToEndAsyncTest : public testing::Test {
  public:
   EndToEndAsyncTest() {
   }
 
   virtual void SetUp() {
     // Make the main thread not to allow IO.
     base::ThreadRestrictions::SetIOAllowed(false);
@@ skipping 273 matching lines @@
 
   // Check the responses.
   WaitForResponses(3);
   // Sort as the order of the returned messages is not deterministic.
   std::sort(response_strings_.begin(), response_strings_.end());
   EXPECT_EQ("bar", response_strings_[0]);
   EXPECT_EQ("baz", response_strings_[1]);
   EXPECT_EQ("foo", response_strings_[2]);
 }
 
+TEST_F(EndToEndAsyncTest, Echo_HugePayload) {
+  const std::string kHugePayload(kHugePayloadSize, 'o');
+
+  // Create the method call with a huge payload.
+  dbus::MethodCall method_call("org.chromium.TestInterface", "Echo");
+  dbus::MessageWriter writer(&method_call);
+  writer.AppendString(kHugePayload);
+
+  // Call the method.
+  const int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT;
+  CallMethod(&method_call, timeout_ms);
+
+  // This caused a DCHECK failure before. Ensure that the issue is fixed.
+  WaitForResponses(1);
+  EXPECT_EQ(kHugePayload, response_strings_[0]);
+}
+
 TEST_F(EndToEndAsyncTest, BrokenBus) {
   const char* kHello = "hello";
 
   // Set up a broken bus.
   SetUpBrokenBus();
 
   // Create the method call.
   dbus::MethodCall method_call("org.chromium.TestInterface", "Echo");
   dbus::MessageWriter writer(&method_call);
   writer.AppendString(kHello);
@@ skipping 204 matching lines @@
   // |object_proxy_| should not handle it, and should leave it for the root
   // object proxy |root_object_proxy_|.
   test_service_->SendTestSignalFromRoot(kMessage);
   WaitForTestSignal();
   // Verify the signal was not received by the specific proxy.
   ASSERT_TRUE(test_signal_string_.empty());
   // Verify the string WAS received by the root proxy.
   ASSERT_EQ(kMessage, root_test_signal_string_);
 }
 
+TEST_F(EndToEndAsyncTest, TestHugeSignal) {
+  const std::string kHugeMessage(kHugePayloadSize, 'o');
+
+  // Send the huge signal from the exported object.
+  test_service_->SendTestSignal(kHugeMessage);
+  // This caused a DCHECK failure before. Ensure that the issue is fixed.
+  WaitForTestSignal();
+  ASSERT_EQ(kHugeMessage, test_signal_string_);
+}
+
 class SignalReplacementTest : public EndToEndAsyncTest {
  public:
   SignalReplacementTest() {
   }
 
   virtual void SetUp() {
     // Set up base class.
     EndToEndAsyncTest::SetUp();
 
     // Reconnect the root object proxy's signal handler to a new handler
@@ skipping 35 matching lines @@
   const char kMessage[] = "hello, world";
   // Send the test signal from the exported object.
   test_service_->SendTestSignal(kMessage);
   // Receive the signal with the object proxy.
   WaitForTestSignal();
   // Verify the string WAS NOT received by the original handler.
   ASSERT_TRUE(test_signal_string_.empty());
   // Verify the signal WAS received by the replacement handler.
   ASSERT_EQ(kMessage, replacement_test_signal_string_);
 }