[Password Generation] Add negative votes for crowdsourcing

chrome/browser/password_manager/native_backend_kwallet_x_unittest.cc

 // Copyright (c) 2012 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 <algorithm>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 207 matching lines @@
   }
   EXPECT_EQ(expected.blacklisted_by_user, actual.blacklisted_by_user);
   EXPECT_EQ(expected.type, actual.type);
   EXPECT_EQ(expected.times_used, actual.times_used);
   EXPECT_EQ(expected.scheme, actual.scheme);
   EXPECT_EQ(expected.date_synced, actual.date_synced);
   EXPECT_EQ(expected.display_name, actual.display_name);
   EXPECT_EQ(expected.avatar_url, actual.avatar_url);
   EXPECT_EQ(expected.federation_url, actual.federation_url);
   EXPECT_EQ(expected.skip_zero_click, actual.skip_zero_click);
+  EXPECT_EQ(expected.generation_upload_status, actual.generation_upload_status);
 }
 
 // static
 void NativeBackendKWalletTestBase::CheckPasswordChanges(
     const PasswordStoreChangeList& expected,
     const PasswordStoreChangeList& actual) {
   ASSERT_EQ(expected.size(), actual.size());
   for (size_t i = 0; i < expected.size(); ++i) {
     EXPECT_EQ(expected[i].type(), actual[i].type());
     CheckPasswordForm(expected[i].form(), actual[i].form(), true);
@@ skipping 720 matching lines @@
 
 TEST_F(NativeBackendKWalletTest, RemoveLoginsSyncedBetween) {
   TestRemoveLoginsBetween(SYNCED);
 }
 
 // TODO(mdm): add more basic tests here at some point.
 // (For example tests for storing >1 password per realm pickle.)
 
 class NativeBackendKWalletPickleTest : public NativeBackendKWalletTestBase {
  protected:
+  void CreateVersion6Pickle(const PasswordForm& form, Pickle* pickle);
   void CreateVersion5Pickle(const PasswordForm& form, Pickle* pickle);
   void CreateVersion3Pickle(const PasswordForm& form, Pickle* pickle);
   void CreateVersion2Pickle(const PasswordForm& form, Pickle* pickle);
   void CreateVersion1Pickle(const PasswordForm& form, Pickle* pickle);
   void CreateVersion0Pickle(bool size_32,
                             const PasswordForm& form,
                             Pickle* pickle);
+  void CheckVersion6Pickle();
   void CheckVersion5Pickle();
   void CheckVersion3Pickle();
   void CheckVersion2Pickle();
   void CheckVersion1Pickle();
   void CheckVersion0Pickle(bool size_32, PasswordForm::Scheme scheme);
 
  private:
   // Creates a Pickle from |form|. If |size_32| is true, stores the number of
   // forms in the pickle as a 32bit uint, otherwise as 64 bit size_t. The latter
   // should be the case for versions > 0. If |date_created_internal| is true,
   // stores |date_created| as base::Time's internal value, otherwise as time_t.
   void CreatePickle(bool size_32,
                     bool date_created_internal,
                     const PasswordForm& form,
                     Pickle* pickle);
 };
 
+void NativeBackendKWalletPickleTest::CreateVersion6Pickle(
+    const PasswordForm& form,
+    Pickle* pickle) {
+  pickle->WriteInt(6);
+  CreatePickle(false, true, form, pickle);
+  pickle->WriteInt(form.type);
+  pickle->WriteInt(form.times_used);
+  autofill::SerializeFormData(form.form_data, pickle);
+  pickle->WriteInt64(form.date_synced.ToInternalValue());
+  pickle->WriteString16(form.display_name);
+  pickle->WriteString(form.avatar_url.spec());
+  pickle->WriteString(form.federation_url.spec());
+  pickle->WriteBool(form.skip_zero_click);
+  pickle->WriteInt(form.generation_upload_status);
+}
+
 void NativeBackendKWalletPickleTest::CreateVersion5Pickle(
     const PasswordForm& form,
     Pickle* pickle) {
   pickle->WriteInt(5);
   CreatePickle(false, true, form, pickle);
   pickle->WriteInt(form.type);
   pickle->WriteInt(form.times_used);
   autofill::SerializeFormData(form.form_data, pickle);
   pickle->WriteInt64(form.date_synced.ToInternalValue());
   pickle->WriteString16(form.display_name);
@@ skipping 51 matching lines @@
   pickle->WriteString16(form.submit_element);
   pickle->WriteBool(form.ssl_valid);
   pickle->WriteBool(form.preferred);
   pickle->WriteBool(form.blacklisted_by_user);
   if (date_created_internal)
     pickle->WriteInt64(form.date_created.ToInternalValue());
   else
     pickle->WriteInt64(form.date_created.ToTimeT());
 }
 
+void NativeBackendKWalletPickleTest::CheckVersion6Pickle() {
+  Pickle pickle;
+  PasswordForm form = form_google_;
+  form.generation_upload_status = PasswordForm::NEGATIVE_SIGNAL_SENT;
+  CreateVersion6Pickle(form, &pickle);
+
+  ScopedVector<PasswordForm> form_list;
+  NativeBackendKWalletStub::DeserializeValue(form.signon_realm, pickle,
+                                             &form_list);
+
+  EXPECT_EQ(1u, form_list.size());
+  if (form_list.size() > 0)
+    CheckPasswordForm(form, *form_list[0], true);
+
+}
+
 void NativeBackendKWalletPickleTest::CheckVersion5Pickle() {
   Pickle pickle;
   PasswordForm form = form_google_;
   CreateVersion5Pickle(form, &pickle);
 
   ScopedVector<PasswordForm> form_list;
   NativeBackendKWalletStub::DeserializeValue(form.signon_realm, pickle,
                                              &form_list);
 
   EXPECT_EQ(1u, form_list.size());
@@ skipping 122 matching lines @@
   CheckVersion2Pickle();
 }
 
 TEST_F(NativeBackendKWalletPickleTest, CheckVersion3Pickle) {
   CheckVersion3Pickle();
 }
 
 TEST_F(NativeBackendKWalletPickleTest, CheckVersion5Pickle) {
   CheckVersion5Pickle();
 }
+
+TEST_F(NativeBackendKWalletPickleTest, CheckVersion6Pickle) {
+  CheckVersion6Pickle();
+}