Fixed synchronization autocomplete unrecoverable error.

components/browser_sync/profile_sync_service_autofill_unittest.cc

 // Copyright 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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <set>
 #include <string>
@@ skipping 94 matching lines @@
                                 true);
   registry->RegisterIntegerPref(autofill::prefs::kAutofillLastVersionDeduped,
                                 atoi(version_info::GetVersionNumber().c_str()));
 }
 
 void RunAndSignal(const base::Closure& cb, WaitableEvent* event) {
   cb.Run();
   event->Signal();
 }
 
-AutofillEntry MakeAutofillEntry(const char* name,
-                                const char* value,
+AutofillEntry MakeAutofillEntry(const std::string& name,
+                                const std::string& value,
                                 int time_shift0,
                                 int time_shift1) {
   // Time deep in the past would cause Autocomplete sync to discard the
   // entries.
   static Time base_time = Time::Now().LocalMidnight();
 
   Time date_created = base_time + TimeDelta::FromSeconds(time_shift0);
   Time date_last_used = date_created;
   if (time_shift1 >= 0)
     date_last_used = base_time + TimeDelta::FromSeconds(time_shift1);
   return AutofillEntry(AutofillKey(ASCIIToUTF16(name), ASCIIToUTF16(value)),
                        date_created, date_last_used);
 }
 
-AutofillEntry MakeAutofillEntry(const char* name,
-                                const char* value,
+AutofillEntry MakeAutofillEntry(const std::string& name,
+                                const std::string& value,
                                 int time_shift) {
   return MakeAutofillEntry(name, value, time_shift, -1);
 }
 
 }  // namespace
 
 class AutofillTableMock : public AutofillTable {
  public:
   AutofillTableMock() {}
   MOCK_METHOD2(RemoveFormElement,
@@ skipping 787 matching lines @@
   std::vector<AutofillEntry> new_sync_entries;
   std::vector<AutofillProfile> new_sync_profiles;
   ASSERT_TRUE(
       GetAutofillEntriesFromSyncDB(&new_sync_entries, &new_sync_profiles));
   std::set<AutofillEntry> new_sync_entries_set(new_sync_entries.begin(),
                                                new_sync_entries.end());
 
   EXPECT_EQ(expected_entries, new_sync_entries_set);
 }
 
+TEST_F(ProfileSyncServiceAutofillTest, HasNativeHasSyncNoMerge_NullTerminated) {
+  const char kEntry[] = "entry";
+  // A value which contains null terminating symbol.
+  std::string entry(kEntry, arraysize(kEntry));
+  AutofillEntry native_entry0(MakeAutofillEntry("native", kEntry, 1));
+  AutofillEntry native_entry1(MakeAutofillEntry("native", entry, 1));
+  AutofillEntry sync_entry0(MakeAutofillEntry("sync", kEntry, 2));
+  AutofillEntry sync_entry1(MakeAutofillEntry("sync", entry, 2));
+
+  std::vector<AutofillEntry> native_entries;
+  native_entries.push_back(native_entry0);
+  native_entries.push_back(native_entry1);
+
+  EXPECT_CALL(autofill_table(), GetAllAutofillEntries(_))
+      .WillOnce(DoAll(SetArgumentPointee<0>(native_entries), Return(true)));
+
+  std::vector<AutofillEntry> sync_entries;
+  sync_entries.push_back(sync_entry0);
+  sync_entries.push_back(sync_entry1);
+
+  AddAutofillHelper<AutofillEntry> add_autofill(this, sync_entries);
+
+  // Expecting that sync_entry0 and sync_entry1 will be written in an autofill
+  // table and a value in sync_entry1 won't lose null terminating symbol.
+  EXPECT_CALL(autofill_table(),
+              UpdateAutofillEntries(ElementsAre(sync_entry0, sync_entry1)))
+      .WillOnce(Return(true));
+
+  EXPECT_CALL(personal_data_manager(), Refresh());
+  StartSyncService(add_autofill.callback(), false, AUTOFILL);
+  ASSERT_TRUE(add_autofill.success());
+
+  // Expecting that native_entry0 and native_entry1 won't merge into one entry.
+  std::set<AutofillEntry> expected_entries;
+  expected_entries.insert(native_entry0);
+  expected_entries.insert(native_entry1);
+  expected_entries.insert(sync_entry0);
+  expected_entries.insert(sync_entry1);
+
+  std::vector<AutofillEntry> new_sync_entries;
+  std::vector<AutofillProfile> new_sync_profiles;
+  ASSERT_TRUE(
+      GetAutofillEntriesFromSyncDB(&new_sync_entries, &new_sync_profiles));
+  std::set<AutofillEntry> new_sync_entries_set(new_sync_entries.begin(),
+                                               new_sync_entries.end());
+
+  EXPECT_EQ(expected_entries, new_sync_entries_set);
+}
+
 TEST_F(ProfileSyncServiceAutofillTest, HasNativeHasSyncMergeEntry) {
   AutofillEntry native_entry(MakeAutofillEntry("merge", "entry", 1));
   AutofillEntry sync_entry(MakeAutofillEntry("merge", "entry", 2));
   AutofillEntry merged_entry(MakeAutofillEntry("merge", "entry", 1, 2));
 
   std::vector<AutofillEntry> native_entries;
   native_entries.push_back(native_entry);
   EXPECT_CALL(autofill_table(), GetAllAutofillEntries(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(native_entries), Return(true)));
 
@@ skipping 553 matching lines @@
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&sync_entries, &sync_profiles));
   EXPECT_EQ(3U, sync_entries.size());
   EXPECT_EQ(0U, sync_profiles.size());
   for (size_t i = 0; i < sync_entries.size(); i++) {
     DVLOG(1) << "Entry " << i << ": " << sync_entries[i].key().name() << ", "
              << sync_entries[i].key().value();
   }
 }
 
 }  // namespace browser_sync