Fill is_chrome_signin_password field in the password entry pings.

components/safe_browsing/password_protection/password_protection_service_unittest.cc

 // Copyright 2017 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/safe_browsing/password_protection/password_protection_service.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/null_task_runner.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/safe_browsing/password_protection/password_protection_request.h"
 #include "components/safe_browsing_db/test_database_manager.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "google_apis/gaia/gaia_urls.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const char kFormActionUrl[] = "https://form_action.com/";
 const char kPasswordFrameUrl[] = "https://password_frame.com/";
 const char kSavedDomain[] = "saved_domain.com";
 const char kTargetUrl[] = "http://foo.com/";
@@ skipping 137 matching lines @@
     EXPECT_CALL(*database_manager_.get(), MatchCsdWhitelistUrl(target_url))
         .WillRepeatedly(testing::Return(match_whitelist));
 
     request_ = new PasswordProtectionRequest(
         nullptr, target_url, GURL(kFormActionUrl), GURL(kPasswordFrameUrl),
         std::string(), LoginReputationClientRequest::UNFAMILIAR_LOGIN_PAGE,
         password_protection_service_.get(), timeout_in_ms);
     request_->Start();
   }
 
-  void InitializeAndStartPasswordEntryRequest(bool match_whitelist,
+  void InitializeAndStartPasswordEntryRequest(const std::string& saved_domain,
+                                              bool match_whitelist,
                                               int timeout_in_ms) {
     GURL target_url(kTargetUrl);
     EXPECT_CALL(*database_manager_.get(), MatchCsdWhitelistUrl(target_url))
         .WillRepeatedly(testing::Return(match_whitelist));
 
     request_ = new PasswordProtectionRequest(
-        nullptr, target_url, GURL(), GURL(), std::string(kSavedDomain),
+        nullptr, target_url, GURL(), GURL(), saved_domain,
         LoginReputationClientRequest::PASSWORD_REUSE_EVENT,
         password_protection_service_.get(), timeout_in_ms);
     request_->Start();
   }
 
   bool PathVariantsMatchCacheExpression(const GURL& url,
                                         const std::string& cache_expression) {
     std::vector<std::string> paths;
     PasswordProtectionService::GeneratePathVariantsWithoutQuery(url, &paths);
     return PasswordProtectionService::PathVariantsMatchCacheExpression(
@@ skipping 424 matching lines @@
             actual_request->trigger_type());
   ASSERT_EQ(2, actual_request->frames_size());
   EXPECT_EQ(kTargetUrl, actual_request->frames(0).url());
   EXPECT_EQ(kPasswordFrameUrl, actual_request->frames(1).url());
   EXPECT_EQ(true, actual_request->frames(1).has_password_field());
   ASSERT_EQ(1, actual_request->frames(1).forms_size());
   EXPECT_EQ(kFormActionUrl, actual_request->frames(1).forms(0).action_url());
 }
 
 TEST_F(PasswordProtectionServiceTest,
-       VerifyProtectedPasswordEntryRequestProto) {
+       VerifyChromeSiginPasswordEntryRequestProto) {
   // Set up valid response.
   net::TestURLFetcher fetcher(0, GURL("http://bar.com"), nullptr);
   fetcher.set_status(
       net::URLRequestStatus(net::URLRequestStatus::SUCCESS, net::OK));
   fetcher.set_response_code(200);
   LoginReputationClientResponse expected_response = CreateVerdictProto(
       LoginReputationClientResponse::PHISHING, 600, GURL(kTargetUrl).host());
   fetcher.SetResponseString(expected_response.SerializeAsString());
-  InitializeAndStartPasswordEntryRequest(false /* match whitelist */,
+  InitializeAndStartPasswordEntryRequest(
+      GaiaUrls::GetInstance()->gaia_url().GetOrigin().spec(),
+      false /* match whitelist */, 100000 /* timeout in ms*/);
+  base::RunLoop().RunUntilIdle();
+  request_->OnURLFetchComplete(&fetcher);
+  base::RunLoop().RunUntilIdle();
+
+  LoginReputationClientRequest* actual_request =
+      password_protection_service_->GetLatestRequestProto();
+  EXPECT_EQ(kTargetUrl, actual_request->page_url());
+  EXPECT_EQ(LoginReputationClientRequest::PASSWORD_REUSE_EVENT,
+            actual_request->trigger_type());
+  EXPECT_EQ(1, actual_request->frames_size());
+  EXPECT_EQ(kTargetUrl, actual_request->frames(0).url());
+  ASSERT_TRUE(actual_request->has_password_reuse_event());
+  EXPECT_TRUE(

[vakh (use Gerrit instead), 2017/06/01 00:02:25]

I think this should be an ASSERT

[Jialiu Lin, 2017/06/01 01:22:01]

Done.

+      actual_request->password_reuse_event().is_chrome_signin_password());
+}
+
+TEST_F(PasswordProtectionServiceTest,
+       VerifyPasswordManagerPasswordEntryRequestProto) {
+  // Set up valid response.
+  net::TestURLFetcher fetcher(0, GURL("http://bar.com"), nullptr);

[vakh (use Gerrit instead), 2017/06/01 00:02:25]

There's plenty of overlap in these tests. Do you think it would be useful to
write a common function that does the common things?

[Jialiu Lin, 2017/06/01 01:22:01]

I'll combine these two tests, such that they can share common setup code.

+  fetcher.set_status(
+      net::URLRequestStatus(net::URLRequestStatus::SUCCESS, net::OK));
+  fetcher.set_response_code(200);
+  LoginReputationClientResponse expected_response = CreateVerdictProto(
+      LoginReputationClientResponse::PHISHING, 600, GURL(kTargetUrl).host());
+  fetcher.SetResponseString(expected_response.SerializeAsString());
+  InitializeAndStartPasswordEntryRequest(std::string(kSavedDomain),
+                                         false /* match whitelist */,
                                          100000 /* timeout in ms*/);
   base::RunLoop().RunUntilIdle();
   request_->OnURLFetchComplete(&fetcher);
   base::RunLoop().RunUntilIdle();
 
   LoginReputationClientRequest* actual_request =
       password_protection_service_->GetLatestRequestProto();
   EXPECT_EQ(kTargetUrl, actual_request->page_url());
   EXPECT_EQ(LoginReputationClientRequest::PASSWORD_REUSE_EVENT,
             actual_request->trigger_type());
   EXPECT_EQ(1, actual_request->frames_size());
   EXPECT_EQ(kTargetUrl, actual_request->frames(0).url());
-  // TODO(jialiul): Update this test when we're ready to fill more fields.
-  ASSERT_FALSE(actual_request->has_password_reuse_event());
+  ASSERT_TRUE(actual_request->has_password_reuse_event());
+  EXPECT_FALSE(
+      actual_request->password_reuse_event().is_chrome_signin_password());
 }
 
 }  // namespace safe_browsing