Add an API test to exersize the open error case. This is a regression test for

chrome/browser/extensions/api/cast_channel/cast_channel_apitest.cc

 // Copyright 2013 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/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "chrome/browser/extensions/api/cast_channel/cast_channel_api.h"
 #include "chrome/browser/extensions/api/cast_channel/cast_socket.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/api/cast_channel.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/capturing_net_log.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gmock_mutant.h"
 
 namespace cast_channel =  extensions::api::cast_channel;
 using cast_channel::CastSocket;
+using cast_channel::ChannelError;
 using cast_channel::ChannelInfo;
 using cast_channel::MessageInfo;
 
+using ::testing::_;
 using ::testing::A;
-using ::testing::_;
+using ::testing::DoAll;
 using ::testing::Invoke;
 using ::testing::Return;
 
 namespace {
 
 const char kTestExtensionId[] = "ddchlicdkolnonkihahngkmmmjnjlkkf";
 const char kTestUrl[] = "cast://192.168.1.1:8009";
 
 static void FillMessageInfo(MessageInfo* message_info,
                             const std::string& message) {
   message_info->namespace_ = "foo";
   message_info->source_id = "src";
   message_info->destination_id = "dest";
   message_info->data.reset(new base::StringValue(message));
 }
 
 ACTION_TEMPLATE(InvokeCompletionCallback,
                 HAS_1_TEMPLATE_PARAMS(int, k),
                 AND_1_VALUE_PARAMS(result)) {
   ::std::tr1::get<k>(args).Run(result);
 }
 
+ACTION_P2(InvokeDelegateOnError, api_test, api) {
+  api_test->CallOnError(api);
+}
+
 class MockCastSocket : public CastSocket {
  public:
   explicit MockCastSocket(CastSocket::Delegate* delegate,
                           net::NetLog* net_log)
       : CastSocket(kTestExtensionId, GURL(kTestUrl), delegate, net_log) {}
   virtual ~MockCastSocket() {}
 
   virtual bool CalledOnValidThread() const OVERRIDE {
     // Always return true in testing.
     return true;
@@ skipping 37 matching lines @@
     channel_info->error_state = cast_channel::CHANNEL_ERROR_NONE;
   }
 
   static void FillChannelInfoForClosedState(ChannelInfo* channel_info) {
     channel_info->channel_id = 1;
     channel_info->url = kTestUrl;
     channel_info->ready_state = cast_channel::READY_STATE_CLOSED;
     channel_info->error_state = cast_channel::CHANNEL_ERROR_NONE;
   }
 
+  void CallOnError(extensions::CastChannelAPI* api) {
+    api->OnError(mock_cast_socket_,
+                 cast_channel::CHANNEL_ERROR_CONNECT_ERROR);
+  }
+
  protected:
   void CallOnMessage(const std::string& message) {
     content::BrowserThread::PostTask(
         content::BrowserThread::IO,
         FROM_HERE,
         base::Bind(&CastChannelAPITest::DoCallOnMessage, this,
-                   GetApi(), mock_cast_socket_, message));
+                   mock_cast_socket_, message));
   }
 
-  void DoCallOnMessage(extensions::CastChannelAPI* api,
-                       MockCastSocket* cast_socket,
+  void DoCallOnMessage(MockCastSocket* cast_socket,
                        const std::string& message) {
     MessageInfo message_info;
     FillMessageInfo(&message_info, message);
-    api->OnMessage(cast_socket, message_info);
+    GetApi()->OnMessage(cast_socket, message_info);
   }
 
   MockCastSocket* mock_cast_socket_;
   ChannelInfo channel_info;
   net::CapturingNetLog capturing_net_log_;
 };
 
 // TODO(munjal): Win Dbg has a workaround that makes RunExtensionSubtest
 // always return true without actually running the test. Remove when fixed.
 #if defined(OS_WIN) && !defined(NDEBUG)
@@ skipping 44 matching lines @@
       WillOnce(InvokeCompletionCallback<0>(net::OK));
 
   EXPECT_TRUE(RunExtensionSubtest("cast_channel/api",
                                   "test_open_receive_close.html"));
 
   ResultCatcher catcher;
   CallOnMessage("some-message");
   CallOnMessage("some-message");
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
+
+// TODO(munjal): Win Dbg has a workaround that makes RunExtensionSubtest
+// always return true without actually running the test. Remove when fixed.
+#if defined(OS_WIN) && !defined(NDEBUG)
+#define MAYBE_TestOpenError DISABLED_TestOpenError
+#else
+#define MAYBE_TestOpenError TestOpenError
+#endif
+// Test the case when socket open results in an error.
+IN_PROC_BROWSER_TEST_F(CastChannelAPITest, MAYBE_TestOpenError) {
+  SetUpMockCastSocket();
+
+  EXPECT_CALL(*mock_cast_socket_, Connect(_))
+        .WillOnce(DoAll(

[Wez, 2014/03/04 21:29:53]

nit: Indentation

[Munjal (Google), 2014/05/21 22:41:06]

It is indented 4 spaces from .WillOnce. That is not good?

[Wez, 2014/05/21 22:57:34]

Indentation of .WillOnce is six from EXPECT_CALL, rather than four.

+            InvokeDelegateOnError(this, GetApi()),
+            InvokeCompletionCallback<0>(net::ERR_FAILED)));
+  EXPECT_CALL(*mock_cast_socket_, FillChannelInfo(_))
+      .WillOnce(Invoke(FillChannelInfoForClosedState))
+      .WillOnce(Invoke(FillChannelInfoForClosedState));
+  EXPECT_CALL(*mock_cast_socket_, Close(_));
+
+  EXPECT_TRUE(RunExtensionSubtest("cast_channel/api",
+                                  "test_open_error.html"));
+
+  ResultCatcher catcher;
+  EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
+}