chrome.gcdPrivate allows app to choose pairing method.

chrome/browser/local_discovery/privetv3_setup_flow_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 "chrome/browser/local_discovery/privetv3_setup_flow.h"
 
 #include "base/json/json_reader.h"
 #include "base/run_loop.h"
 #include "chrome/browser/local_discovery/gcd_api_flow.h"
 #include "net/http/http_response_headers.h"
@@ skipping 76 matching lines @@
 
   MOCK_METHOD1(GetWiFiCredentials, void(const CredentialsCallback&));
   MOCK_METHOD1(SwitchToSetupWiFi, void(const ResultCallback&));
   virtual void CreatePrivetV3Client(
       const std::string& service_name,
       const PrivetClientCallback& callback) override {
     scoped_ptr<MockPrivetHTTPClient> privet_client(new MockPrivetHTTPClient());
     privet_client_ptr_ = privet_client.get();
     callback.Run(privet_client.Pass());
   }
-  MOCK_METHOD2(ConfirmSecurityCode,
-               void(const std::string&, const ResultCallback&));
+  MOCK_METHOD1(ConfirmSecurityCode, void(const ResultCallback&));
   MOCK_METHOD1(RestoreWifi, void(const ResultCallback&));
   MOCK_METHOD0(OnSetupDone, void());
   MOCK_METHOD0(OnSetupError, void());
 
   virtual scoped_ptr<GCDApiFlow> CreateApiFlow() override {
     return make_scoped_ptr(new MockGCDApiFlow(this));
   }
 
   void ReplyWithToken() {
     scoped_ptr<base::Value> value(base::JSONReader::Read(gcd_server_response_));
@@ skipping 17 matching lines @@
   void ConfirmCode(const MockDelegate::ResultCallback& confirm_callback) {
     base::MessageLoop::current()->PostTask(FROM_HERE, quit_closure_);
     confirm_callback.Run(true);
   }
 
  protected:
   virtual void SetUp() override {
     quit_closure_ = run_loop_.QuitClosure();
     EXPECT_CALL(delegate_, GetWiFiCredentials(_)).Times(0);
     EXPECT_CALL(delegate_, SwitchToSetupWiFi(_)).Times(0);
-    EXPECT_CALL(delegate_, ConfirmSecurityCode(_, _)).Times(0);
+    EXPECT_CALL(delegate_, ConfirmSecurityCode(_)).Times(0);
     EXPECT_CALL(delegate_, RestoreWifi(_)).Times(0);
     EXPECT_CALL(delegate_, OnSetupDone()).Times(0);
     EXPECT_CALL(delegate_, OnSetupError()).Times(0);
   }
 
   void SimulateFetch(int response_code, const std::string& response) {
     net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
     ASSERT_TRUE(fetcher);
     EXPECT_THAT(fetcher->GetOriginalURL().spec(),
                 testing::HasSubstr("/privet/v3/setup/start"));
@@ skipping 15 matching lines @@
 };
 
 TEST_F(PrivetV3SetupFlowTest, InvalidTicket) {
   EXPECT_CALL(delegate_, OnSetupError()).Times(1);
   delegate_.gcd_server_response_ = "{}";
   setup_.Register(kServiceName);
 }
 
 TEST_F(PrivetV3SetupFlowTest, InvalidDeviceResponce) {
   EXPECT_CALL(delegate_, OnSetupError()).Times(1);
-  EXPECT_CALL(delegate_, ConfirmSecurityCode(_, _)).Times(1).WillOnce(
-      WithArgs<1>(Invoke(this, &PrivetV3SetupFlowTest::ConfirmCode)));
+  EXPECT_CALL(delegate_, ConfirmSecurityCode(_))
+      .Times(1)
+      .WillOnce(WithArgs<0>(Invoke(this, &PrivetV3SetupFlowTest::ConfirmCode)));
   delegate_.gcd_server_response_ = kRegistrationTicketResponse;
   setup_.Register(kServiceName);
   run_loop_.Run();
   SimulateFetch(0, "{}");
 }
 
 TEST_F(PrivetV3SetupFlowTest, Success) {
   EXPECT_CALL(delegate_, OnSetupDone()).Times(1);
-  EXPECT_CALL(delegate_, ConfirmSecurityCode(_, _)).Times(1).WillOnce(
-      WithArgs<1>(Invoke(this, &PrivetV3SetupFlowTest::ConfirmCode)));
+  EXPECT_CALL(delegate_, ConfirmSecurityCode(_))
+      .Times(1)
+      .WillOnce(WithArgs<0>(Invoke(this, &PrivetV3SetupFlowTest::ConfirmCode)));
   delegate_.gcd_server_response_ = kRegistrationTicketResponse;
   setup_.Register(kServiceName);
   run_loop_.Run();
   SimulateFetch(200, "{}");
 }
 
 }  // namespace
 
 }  // namespace local_discovery