Disable CredentialManagerClientTest on Android

components/password_manager/content/renderer/credential_manager_client_browsertest.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 "components/password_manager/content/common/credential_manager_messages.h"
 #include "components/password_manager/content/renderer/credential_manager_client.h"
 #include "content/public/test/render_view_test.h"
 #include "ipc/ipc_test_sink.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebCredential.h"
 #include "third_party/WebKit/public/platform/WebCredentialManagerClient.h"
 #include "third_party/WebKit/public/platform/WebCredentialManagerError.h"
 #include "third_party/WebKit/public/platform/WebLocalCredential.h"
 
 namespace password_manager {
 
 namespace {
 
-class CredentialManagerClientTest : public content::RenderViewTest {
+// This test has crashed on Android since commit
+// d94a4430bc4448406b7564790d06110c7c5bcaaf was merged.
+// http://crbug.com/481415
+#if defined(OS_ANDROID)
+#define MAYBE_CredentialManagerClientTest DISABLED_CredentialManagerClientTest
+#else
+#define MAYBE_CredentialManagerClientTest CredentialManagerClientTest
+#endif  // defined(OS_ANDROID)
+
+class MAYBE_CredentialManagerClientTest : public content::RenderViewTest {
  public:
-  CredentialManagerClientTest()
+  MAYBE_CredentialManagerClientTest()
       : callback_errored_(false), callback_succeeded_(false) {}
-  ~CredentialManagerClientTest() override {}
+  ~MAYBE_CredentialManagerClientTest() override {}
 
   void SetUp() override {
     content::RenderViewTest::SetUp();
     credential_.reset(new blink::WebLocalCredential("", "", GURL(), ""));
     client_.reset(new CredentialManagerClient(view_));
   }
 
   void TearDown() override {
     credential_.reset();
     content::RenderViewTest::TearDown();
@@ skipping 67 matching lines @@
   // pending Blink-side Promise.
   bool callback_errored_;
   bool callback_succeeded_;
 
   scoped_ptr<blink::WebLocalCredential> credential_;
 };
 
 class TestNotificationCallbacks
     : public blink::WebCredentialManagerClient::NotificationCallbacks {
  public:
-  explicit TestNotificationCallbacks(CredentialManagerClientTest* test)
+  explicit TestNotificationCallbacks(MAYBE_CredentialManagerClientTest* test)
       : test_(test) {}
 
   virtual ~TestNotificationCallbacks() {}
 
   virtual void onSuccess() { test_->set_callback_succeeded(true); }
 
   virtual void onError(blink::WebCredentialManagerError* reason) {
     test_->set_callback_errored(true);
   }
 
  private:
-  CredentialManagerClientTest* test_;
+  MAYBE_CredentialManagerClientTest* test_;
 };
 
 class TestRequestCallbacks
     : public blink::WebCredentialManagerClient::RequestCallbacks {
  public:
-  explicit TestRequestCallbacks(CredentialManagerClientTest* test)
+  explicit TestRequestCallbacks(MAYBE_CredentialManagerClientTest* test)
       : test_(test) {}
 
   virtual ~TestRequestCallbacks() {}
 
   virtual void onSuccess(blink::WebCredential*) {
     test_->set_callback_succeeded(true);
   }
 
   virtual void onError(blink::WebCredentialManagerError* reason) {
     test_->set_callback_errored(true);
   }
 
  private:
-  CredentialManagerClientTest* test_;
+  MAYBE_CredentialManagerClientTest* test_;
 };
 
 }  // namespace
 
-TEST_F(CredentialManagerClientTest, SendNotifyFailedSignIn) {
+TEST_F(MAYBE_CredentialManagerClientTest, SendNotifyFailedSignIn) {
   int request_id;
   EXPECT_FALSE(ExtractRequestId(CredentialManagerHostMsg_NotifyFailedSignIn::ID,
                                 request_id));
 
   scoped_ptr<TestNotificationCallbacks> callbacks(
       new TestNotificationCallbacks(this));
   client_->dispatchFailedSignIn(*credential(), callbacks.release());
 
   EXPECT_TRUE(ExtractRequestId(CredentialManagerHostMsg_NotifyFailedSignIn::ID,
                                request_id));
 
   client_->OnAcknowledgeFailedSignIn(request_id);
   EXPECT_TRUE(callback_succeeded());
   EXPECT_FALSE(callback_errored());
 }
 
-TEST_F(CredentialManagerClientTest, SendNotifySignedIn) {
+TEST_F(MAYBE_CredentialManagerClientTest, SendNotifySignedIn) {
   int request_id;
   EXPECT_FALSE(ExtractRequestId(CredentialManagerHostMsg_NotifySignedIn::ID,
                                 request_id));
 
   scoped_ptr<TestNotificationCallbacks> callbacks(
       new TestNotificationCallbacks(this));
   client_->dispatchSignedIn(*credential(), callbacks.release());
 
   EXPECT_TRUE(ExtractRequestId(CredentialManagerHostMsg_NotifySignedIn::ID,
                                request_id));
 
   client_->OnAcknowledgeSignedIn(request_id);
   EXPECT_TRUE(callback_succeeded());
   EXPECT_FALSE(callback_errored());
 }
 
-TEST_F(CredentialManagerClientTest, SendNotifySignedOut) {
+TEST_F(MAYBE_CredentialManagerClientTest, SendNotifySignedOut) {
   int request_id;
   EXPECT_FALSE(ExtractRequestId(CredentialManagerHostMsg_NotifySignedOut::ID,
                                 request_id));
 
   scoped_ptr<TestNotificationCallbacks> callbacks(
       new TestNotificationCallbacks(this));
   client_->dispatchSignedOut(callbacks.release());
 
   EXPECT_TRUE(ExtractRequestId(CredentialManagerHostMsg_NotifySignedOut::ID,
                                request_id));
 
   client_->OnAcknowledgeSignedOut(request_id);
   EXPECT_TRUE(callback_succeeded());
   EXPECT_FALSE(callback_errored());
 }
 
-TEST_F(CredentialManagerClientTest, SendRequestCredential) {
+TEST_F(MAYBE_CredentialManagerClientTest, SendRequestCredential) {
   int request_id;
   EXPECT_FALSE(ExtractRequestId(CredentialManagerHostMsg_RequestCredential::ID,
                                 request_id));
 
   scoped_ptr<TestRequestCallbacks> callbacks(new TestRequestCallbacks(this));
   std::vector<GURL> federations;
   client_->dispatchRequest(false, federations, callbacks.release());
 
   EXPECT_TRUE(ExtractRequestId(CredentialManagerHostMsg_RequestCredential::ID,
                                request_id));
 
   CredentialInfo info;
   info.type = CredentialType::CREDENTIAL_TYPE_LOCAL;
   client_->OnSendCredential(request_id, info);
   EXPECT_TRUE(callback_succeeded());
   EXPECT_FALSE(callback_errored());
 }
 
-TEST_F(CredentialManagerClientTest, SendRequestCredentialEmpty) {
+TEST_F(MAYBE_CredentialManagerClientTest, SendRequestCredentialEmpty) {
   int request_id;
   EXPECT_FALSE(ExtractRequestId(CredentialManagerHostMsg_RequestCredential::ID,
                                 request_id));
 
   scoped_ptr<TestRequestCallbacks> callbacks(new TestRequestCallbacks(this));
   std::vector<GURL> federations;
   client_->dispatchRequest(false, federations, callbacks.release());
 
   EXPECT_TRUE(ExtractRequestId(CredentialManagerHostMsg_RequestCredential::ID,
                                request_id));
 
   CredentialInfo info;  // Send an empty credential in response.
   client_->OnSendCredential(request_id, info);
   EXPECT_TRUE(callback_succeeded());
   EXPECT_FALSE(callback_errored());
 }
 
 }  // namespace password_manager