Fix IPCChannelMojoErrorTest.SendFailWithPendingMessages

ipc/mojo/ipc_channel_mojo_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 "ipc/mojo/ipc_channel_mojo.h"
 
 #include "base/base_paths.h"
 #include "base/files/file.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
@@ skipping 140 matching lines @@
 
   IPC::TestChannelListener::SendOneMessage(
       client.channel(), "hello from child");
   base::MessageLoop::current()->Run();
   EXPECT_TRUE(listener.is_connected_called());
   EXPECT_TRUE(listener.HasSentAll());
 
   return 0;
 }
 
-// Close given handle before use to simulate an error.
-class ErraticChannelMojo : public IPC::ChannelMojo {
- public:
-  ErraticChannelMojo(IPC::ChannelMojoHost* host,
-                     const IPC::ChannelHandle& channel_handle,
-                     IPC::Channel::Mode mode,
-                     IPC::Listener* listener,
-                     scoped_refptr<base::TaskRunner> runner)
-      : ChannelMojo(host, channel_handle, mode, listener) {}
-
-  virtual void OnConnected(mojo::ScopedMessagePipeHandle pipe) {
-    MojoClose(pipe.get().value());
-    OnConnected(pipe.Pass());
-  }
-};
-
-// Exists to create ErraticChannelMojo.
-class ErraticChannelFactory : public IPC::ChannelFactory {
- public:
-  explicit ErraticChannelFactory(IPC::ChannelMojoHost* host,
-                                 const IPC::ChannelHandle& handle,
-                                 base::TaskRunner* runner)
-      : host_(host), handle_(handle), runner_(runner) {}
-
-  virtual std::string GetName() const OVERRIDE {
-    return "";
-  }
-
-  virtual scoped_ptr<IPC::Channel> BuildChannel(
-      IPC::Listener* listener) OVERRIDE {
-    return scoped_ptr<IPC::Channel>(new ErraticChannelMojo(
-        host_, handle_, IPC::Channel::MODE_SERVER, listener, runner_));
-  }
-
- private:
-  IPC::ChannelMojoHost* host_;
-  IPC::ChannelHandle handle_;
-  scoped_refptr<base::TaskRunner> runner_;
-};
-
 class ListenerExpectingErrors : public IPC::Listener {
  public:
   ListenerExpectingErrors()
       : has_error_(false) {
   }
 
+  virtual void OnChannelConnected(int32 peer_pid) OVERRIDE {
+    base::MessageLoop::current()->Quit();
+  }
+
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
     return true;
   }
 
   virtual void OnChannelError() OVERRIDE {
     has_error_ = true;
     base::MessageLoop::current()->Quit();
   }
 
   bool has_error() const { return has_error_; }
 
  private:
   bool has_error_;
 };
 
 
 class IPCChannelMojoErrorTest : public IPCTestBase {
  protected:
   virtual scoped_ptr<IPC::ChannelFactory> CreateChannelFactory(
       const IPC::ChannelHandle& handle,
       base::TaskRunner* runner) OVERRIDE {
     host_.reset(new IPC::ChannelMojoHost(task_runner()));
-    return scoped_ptr<IPC::ChannelFactory>(
-        new ErraticChannelFactory(host_.get(), handle, runner));
+    return IPC::ChannelMojo::CreateServerFactory(host_.get(), handle);
   }
 
   virtual bool DidStartClient() OVERRIDE {
     bool ok = IPCTestBase::DidStartClient();
     DCHECK(ok);
     host_->OnClientLaunched(client_process());
     return ok;
   }
 
  private:
@@ skipping 18 matching lines @@
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(IPCChannelMojoErraticTestClient) {
   ListenerThatQuits listener;
   ChannelClient client(&listener, "IPCChannelMojoErraticTestClient");
   client.Connect();
 
   base::MessageLoop::current()->Run();
 
   return 0;
 }
 
-// https://crbug.com/417439
-TEST_F(IPCChannelMojoErrorTest, DISABLED_SendFailWithPendingMessages) {
+TEST_F(IPCChannelMojoErrorTest, SendFailWithPendingMessages) {
   Init("IPCChannelMojoErraticTestClient");
 
   // Set up IPC channel and start client.
   ListenerExpectingErrors listener;
   CreateChannel(&listener);
   ASSERT_TRUE(ConnectChannel());
 
+  // This matches a value in mojo/system/constants.h
+  const int kMaxMessageNumBytes = 4 * 1024 * 1024;
+  std::string overly_large_data(kMaxMessageNumBytes, '*');
   // This messages are queued as pending.
-  for (size_t i = 0; i < 2; ++i) {
+  for (size_t i = 0; i < 10; ++i) {
     IPC::TestChannelListener::SendOneMessage(
-        sender(), "hello from parent");
+        sender(), overly_large_data.c_str());
   }
 
   ASSERT_TRUE(StartClient());
   base::MessageLoop::current()->Run();
 
   this->channel()->Close();
 
   EXPECT_TRUE(WaitForClientShutdown());
   EXPECT_TRUE(listener.has_error());
 
@@ skipping 82 matching lines @@
   client.Connect();
   listener.set_sender(client.channel());
 
   base::MessageLoop::current()->Run();
 
   return 0;
 }
 #endif
 
 }  // namespace