Update webdata files to take advantage of DLOG(FATAL) in

chrome/browser/webdata/autofill_table.cc

 // Copyright (c) 2011 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/webdata/autofill_table.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <set>
@@ skipping 121 matching lines @@
 
   return credit_card;
 }
 
 bool AddAutofillProfileNamesToProfile(sql::Connection* db,
                                       AutofillProfile* profile) {
   sql::Statement s(db->GetUniqueStatement(
       "SELECT guid, first_name, middle_name, last_name "
       "FROM autofill_profile_names "
       "WHERE guid=?"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
+  s.BindString(0, profile->guid());
+
+  if (!s.is_valid())
     return false;
-  }
-  s.BindString(0, profile->guid());
 
   std::vector<string16> first_names;
   std::vector<string16> middle_names;
   std::vector<string16> last_names;
   while (s.Step()) {
     DCHECK_EQ(profile->guid(), s.ColumnString(0));
     first_names.push_back(s.ColumnString16(1));
     middle_names.push_back(s.ColumnString16(2));
     last_names.push_back(s.ColumnString16(3));
   }
+  if (!s.Succeeded())
+    return false;

[Scott Hess - ex-Googler, 2011/12/16 22:37:09]

Yeah, I think this is a reasonable pattern for the problem.  Fortunately it was
creating locally-scoped things rather than forwarding to the profile live...

+
   profile->SetMultiInfo(NAME_FIRST, first_names);
   profile->SetMultiInfo(NAME_MIDDLE, middle_names);
   profile->SetMultiInfo(NAME_LAST, last_names);
   return true;
 }
 
 bool AddAutofillProfileEmailsToProfile(sql::Connection* db,
                                        AutofillProfile* profile) {
   sql::Statement s(db->GetUniqueStatement(
       "SELECT guid, email "
       "FROM autofill_profile_emails "
       "WHERE guid=?"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
+  s.BindString(0, profile->guid());
+
+  if (!s.is_valid())
     return false;
-  }
-  s.BindString(0, profile->guid());
 
   std::vector<string16> emails;
   while (s.Step()) {
     DCHECK_EQ(profile->guid(), s.ColumnString(0));
     emails.push_back(s.ColumnString16(1));
   }
+  if (!s.Succeeded())
+    return false;
+
   profile->SetMultiInfo(EMAIL_ADDRESS, emails);
   return true;
 }
 
 bool AddAutofillProfilePhonesToProfile(sql::Connection* db,
                                        AutofillProfile* profile) {
   sql::Statement s(db->GetUniqueStatement(
       "SELECT guid, type, number "
       "FROM autofill_profile_phones "
       "WHERE guid=? AND type=?"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
+
+  // Value used to be either [(0, phone), (1, fax)] but fax has been removed.
+  s.BindString(0, profile->guid());
+  s.BindInt(1, 0);
+
+  if (!s.is_valid())
     return false;
-  }
-  s.BindString(0, profile->guid());
-  // Value used to be either [(0, phone), (1, fax)] but fax has been removed.
-  s.BindInt(1, 0);
 
   std::vector<string16> numbers;
   while (s.Step()) {
     DCHECK_EQ(profile->guid(), s.ColumnString(0));
     numbers.push_back(s.ColumnString16(2));
   }
+  if (!s.Succeeded())
+    return false;
+
   profile->SetMultiInfo(PHONE_HOME_WHOLE_NUMBER, numbers);
   return true;
 }
 
 bool AddAutofillProfileNames(const AutofillProfile& profile,
                              sql::Connection* db) {
   std::vector<string16> first_names;
   profile.GetMultiInfo(NAME_FIRST, &first_names);
   std::vector<string16> middle_names;
   profile.GetMultiInfo(NAME_MIDDLE, &middle_names);
   std::vector<string16> last_names;
   profile.GetMultiInfo(NAME_LAST, &last_names);
   DCHECK_EQ(first_names.size(), middle_names.size());
   DCHECK_EQ(middle_names.size(), last_names.size());
 
   for (size_t i = 0; i < first_names.size(); ++i) {
     // Add the new name.
     sql::Statement s(db->GetUniqueStatement(
       "INSERT INTO autofill_profile_names"
       " (guid, first_name, middle_name, last_name) "
       "VALUES (?,?,?,?)"));
-    if (!s) {
-      NOTREACHED();
-      return false;
-    }
     s.BindString(0, profile.guid());
     s.BindString16(1, first_names[i]);
     s.BindString16(2, middle_names[i]);
     s.BindString16(3, last_names[i]);
 
-    if (!s.Run()) {
-      NOTREACHED();
+    if (!s.Run())
       return false;
-    }
   }
   return true;
 }
 
 bool AddAutofillProfileEmails(const AutofillProfile& profile,
                               sql::Connection* db) {
   std::vector<string16> emails;
   profile.GetMultiInfo(EMAIL_ADDRESS, &emails);
 
   for (size_t i = 0; i < emails.size(); ++i) {
     // Add the new email.
     sql::Statement s(db->GetUniqueStatement(
       "INSERT INTO autofill_profile_emails"
       " (guid, email) "
       "VALUES (?,?)"));
-    if (!s) {
-      NOTREACHED();
-      return false;
-    }
     s.BindString(0, profile.guid());
     s.BindString16(1, emails[i]);
 
-    if (!s.Run()) {
-      NOTREACHED();
+    if (!s.Run())
       return false;
-    }
   }
+
   return true;
 }
 
 bool AddAutofillProfilePhones(const AutofillProfile& profile,
                               sql::Connection* db) {
   std::vector<string16> numbers;
   profile.GetMultiInfo(PHONE_HOME_WHOLE_NUMBER, &numbers);
 
   for (size_t i = 0; i < numbers.size(); ++i) {
     // Add the new number.
     sql::Statement s(db->GetUniqueStatement(
       "INSERT INTO autofill_profile_phones"
       " (guid, type, number) "
       "VALUES (?,?,?)"));
-    if (!s) {
-      NOTREACHED();
-      return false;
-    }
     s.BindString(0, profile.guid());
     // Value used to be either [(0, phone), (1, fax)] but fax has been removed.
     s.BindInt(1, 0);
     s.BindString16(2, numbers[i]);
 
-    if (!s.Run()) {
-      NOTREACHED();
+    if (!s.Run())
       return false;
-    }
   }
 
   return true;
 }
 
 bool AddAutofillProfilePieces(const AutofillProfile& profile,
                               sql::Connection* db) {
   if (!AddAutofillProfileNames(profile, db))
     return false;
 
   if (!AddAutofillProfileEmails(profile, db))
     return false;
 
   if (!AddAutofillProfilePhones(profile, db))
     return false;
 
   return true;
 }
 
 bool RemoveAutofillProfilePieces(const std::string& guid, sql::Connection* db) {
   sql::Statement s1(db->GetUniqueStatement(
       "DELETE FROM autofill_profile_names WHERE guid = ?"));
-  if (!s1) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
+  s1.BindString(0, guid);
 
-  s1.BindString(0, guid);
   if (!s1.Run())
     return false;
 
   sql::Statement s2(db->GetUniqueStatement(
       "DELETE FROM autofill_profile_emails WHERE guid = ?"));
-  if (!s2) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
+  s2.BindString(0, guid);
 
-  s2.BindString(0, guid);
   if (!s2.Run())
     return false;
 
   sql::Statement s3(db->GetUniqueStatement(
       "DELETE FROM autofill_profile_phones WHERE guid = ?"));
-  if (!s3) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
+  s3.BindString(0, guid);
 
-  s3.BindString(0, guid);
   return s3.Run();
 }
 
 }  // namespace
 
 // The maximum length allowed for form data.
 const size_t AutofillTable::kMaxDataLength = 1024;
 
 AutofillTable::AutofillTable(sql::Connection* db, sql::MetaTable* meta_table)
     : WebDatabaseTable(db, meta_table) {
@@ skipping 29 matching lines @@
                                                 int limit) {
   DCHECK(values);
   sql::Statement s;
 
   if (prefix.empty()) {
     s.Assign(db_->GetUniqueStatement(
         "SELECT value FROM autofill "
         "WHERE name = ? "
         "ORDER BY count DESC "
         "LIMIT ?"));
-    if (!s) {
-      NOTREACHED() << "Statement prepare failed";
-      return false;
-    }
-
     s.BindString16(0, name);
     s.BindInt(1, limit);
   } else {
     string16 prefix_lower = base::i18n::ToLower(prefix);
     string16 next_prefix = prefix_lower;
     next_prefix[next_prefix.length() - 1]++;
 
     s.Assign(db_->GetUniqueStatement(
         "SELECT value FROM autofill "
         "WHERE name = ? AND "
         "value_lower >= ? AND "
         "value_lower < ? "
         "ORDER BY count DESC "
         "LIMIT ?"));
-    if (!s) {
-      NOTREACHED() << "Statement prepare failed";
-      return false;
-    }
-
     s.BindString16(0, name);
     s.BindString16(1, prefix_lower);
     s.BindString16(2, next_prefix);
     s.BindInt(3, limit);
   }
 
   values->clear();
   while (s.Step())
     values->push_back(s.ColumnString16(0));
   return s.Succeeded();
 }
 
 bool AutofillTable::RemoveFormElementsAddedBetween(
     const Time& delete_begin,
     const Time& delete_end,
     std::vector<AutofillChange>* changes) {
   DCHECK(changes);
   // Query for the pair_id, name, and value of all form elements that
   // were used between the given times.
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT DISTINCT a.pair_id, a.name, a.value "
       "FROM autofill_dates ad JOIN autofill a ON ad.pair_id = a.pair_id "
       "WHERE ad.date_created >= ? AND ad.date_created < ?"));
-  if (!s) {
-    NOTREACHED() << "Statement 1 prepare failed";
-    return false;
-  }
   s.BindInt64(0, delete_begin.ToTimeT());
   s.BindInt64(1,
               delete_end.is_null() ?
                   std::numeric_limits<int64>::max() :
                   delete_end.ToTimeT());
 
   AutofillElementList elements;
   while (s.Step()) {
     elements.push_back(MakeTuple(s.ColumnInt64(0),
                                  s.ColumnString16(1),
                                  s.ColumnString16(2)));
   }
-
-  if (!s.Succeeded()) {
-    NOTREACHED();
+  if (!s.Succeeded())
     return false;
-  }
 
   for (AutofillElementList::iterator itr = elements.begin();
        itr != elements.end(); itr++) {
     int how_many = 0;
     if (!RemoveFormElementForTimeRange(itr->a, delete_begin, delete_end,
                                        &how_many)) {
       return false;
     }
     bool was_removed = false;
     if (!AddToCountOfFormElement(itr->a, -how_many, &was_removed))
       return false;
     AutofillChange::Type change_type =
         was_removed ? AutofillChange::REMOVE : AutofillChange::UPDATE;
     changes->push_back(AutofillChange(change_type,
                                       AutofillKey(itr->b, itr->c)));
   }
 
   return true;
 }
 
 bool AutofillTable::RemoveFormElementForTimeRange(int64 pair_id,
                                                   const Time& delete_begin,
                                                   const Time& delete_end,
                                                   int* how_many) {
   sql::Statement s(db_->GetUniqueStatement(
       "DELETE FROM autofill_dates WHERE pair_id = ? AND "
       "date_created >= ? AND date_created < ?"));
-  if (!s) {
-    NOTREACHED() << "Statement 1 prepare failed";
-    return false;
-  }
   s.BindInt64(0, pair_id);
   s.BindInt64(1, delete_begin.is_null() ? 0 : delete_begin.ToTimeT());
   s.BindInt64(2, delete_end.is_null() ? std::numeric_limits<int64>::max() :
                                         delete_end.ToTimeT());
 
   bool result = s.Run();
   if (how_many)
     *how_many = db_->GetLastChangeCount();
 
   return result;
@@ skipping 17 matching lines @@
     if (!SetCountOfFormElement(pair_id, count + delta))
       return false;
   }
   return true;
 }
 
 bool AutofillTable::GetIDAndCountOfFormElement(
     const FormField& element,
     int64* pair_id,
     int* count) {
+  DCHECK(pair_id);
+  DCHECK(count);
+
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT pair_id, count FROM autofill "
       "WHERE name = ? AND value = ?"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
-
   s.BindString16(0, element.name);
   s.BindString16(1, element.value);
 
+  if (!s.is_valid())
+    return false;
+
   *pair_id = 0;
   *count = 0;
 
   if (s.Step()) {
     *pair_id = s.ColumnInt64(0);
     *count = s.ColumnInt(1);
   }
 
   return true;
 }
 
 bool AutofillTable::GetCountOfFormElement(int64 pair_id, int* count) {
+  DCHECK(count);
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT count FROM autofill WHERE pair_id = ?"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
-
   s.BindInt64(0, pair_id);
 
   if (s.Step()) {
     *count = s.ColumnInt(0);
     return true;
   }
   return false;
 }
 
 bool AutofillTable::SetCountOfFormElement(int64 pair_id, int count) {
   sql::Statement s(db_->GetUniqueStatement(
       "UPDATE autofill SET count = ? WHERE pair_id = ?"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
-
   s.BindInt(0, count);
   s.BindInt64(1, pair_id);
-  if (!s.Run()) {
-    NOTREACHED();
-    return false;
-  }
 
-  return true;
+  return s.Run();
 }
 
 bool AutofillTable::InsertFormElement(const FormField& element,
                                       int64* pair_id) {
+  DCHECK(pair_id);
   sql::Statement s(db_->GetUniqueStatement(
       "INSERT INTO autofill (name, value, value_lower) VALUES (?,?,?)"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
-
   s.BindString16(0, element.name);
   s.BindString16(1, element.value);
   s.BindString16(2, base::i18n::ToLower(element.value));
 
-  if (!s.Run()) {
-    NOTREACHED();
+  if (!s.Run())
     return false;
-  }
 
   *pair_id = db_->GetLastInsertRowId();
   return true;
 }
 
 bool AutofillTable::InsertPairIDAndDate(int64 pair_id,
                                         const Time& date_created) {
   sql::Statement s(db_->GetUniqueStatement(
       "INSERT INTO autofill_dates "
       "(pair_id, date_created) VALUES (?, ?)"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
-
   s.BindInt64(0, pair_id);
   s.BindInt64(1, date_created.ToTimeT());
 
-  if (!s.Run()) {
-    NOTREACHED();
-    return false;
-  }
-
-  return true;
+  return s.Run();
 }
 
 bool AutofillTable::AddFormFieldValuesTime(
     const std::vector<FormField>& elements,
     std::vector<AutofillChange>* changes,
     Time time) {
   // Only add one new entry for each unique element name.  Use |seen_names| to
   // track this.  Add up to |kMaximumUniqueNames| unique entries per form.
   const size_t kMaximumUniqueNames = 256;
   std::set<string16> seen_names;
   bool result = true;
   for (std::vector<FormField>::const_iterator
        itr = elements.begin();
        itr != elements.end();
        itr++) {
     if (seen_names.size() >= kMaximumUniqueNames)
       break;
     if (seen_names.find(itr->name) != seen_names.end())
       continue;
     result = result && AddFormFieldValueTime(*itr, changes, time);
     seen_names.insert(itr->name);
   }
   return result;
 }
 
 bool AutofillTable::ClearAutofillEmptyValueElements() {
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT pair_id FROM autofill WHERE TRIM(value)= \"\""));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
+  if (!s.is_valid())
     return false;
-  }
 
   std::set<int64> ids;
   while (s.Step())
     ids.insert(s.ColumnInt64(0));
+  if (!s.Succeeded())
+    return false;
 
   bool success = true;
   for (std::set<int64>::const_iterator iter = ids.begin(); iter != ids.end();
        ++iter) {
     if (!RemoveFormElementForID(*iter))
       success = false;
   }
 
   return success;
 }
 
 bool AutofillTable::GetAllAutofillEntries(std::vector<AutofillEntry>* entries) {
   DCHECK(entries);
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT name, value, date_created FROM autofill a JOIN "
       "autofill_dates ad ON a.pair_id=ad.pair_id"));
 
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
-
   bool first_entry = true;
   AutofillKey* current_key_ptr = NULL;
   std::vector<Time>* timestamps_ptr = NULL;
   string16 name, value;
   Time time;
   while (s.Step()) {
     name = s.ColumnString16(0);
     value = s.ColumnString16(1);
     time = Time::FromTimeT(s.ColumnInt64(2));
 
@@ skipping 13 matching lines @@
 
         delete current_key_ptr;
         delete timestamps_ptr;
 
         current_key_ptr = new AutofillKey(name, value);
         timestamps_ptr = new std::vector<Time>;
       }
       timestamps_ptr->push_back(time);
     }
   }
+
+  if (!s.Succeeded())
+    return false;
+
   // If there is at least one result returned, first_entry will be false.
   // For this case we need to do a final cleanup step.
   if (!first_entry) {
     AutofillEntry entry(*current_key_ptr, *timestamps_ptr);
     entries->push_back(entry);
     delete current_key_ptr;
     delete timestamps_ptr;
   }
 
   return s.Succeeded();
 }
 
 bool AutofillTable::GetAutofillTimestamps(const string16& name,
                                           const string16& value,
                                           std::vector<Time>* timestamps) {
   DCHECK(timestamps);
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT date_created FROM autofill a JOIN "
       "autofill_dates ad ON a.pair_id=ad.pair_id "
       "WHERE a.name = ? AND a.value = ?"));
-
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
-
   s.BindString16(0, name);
   s.BindString16(1, value);
+
   while (s.Step())
     timestamps->push_back(Time::FromTimeT(s.ColumnInt64(0)));
 
   return s.Succeeded();
 }
 
 bool AutofillTable::UpdateAutofillEntries(
     const std::vector<AutofillEntry>& entries) {
   if (!entries.size())
     return true;
 
   // Remove all existing entries.
   for (size_t i = 0; i < entries.size(); i++) {
     std::string sql = "SELECT pair_id FROM autofill "
                       "WHERE name = ? AND value = ?";
     sql::Statement s(db_->GetUniqueStatement(sql.c_str()));
-    if (!s.is_valid()) {
-      NOTREACHED() << "Statement prepare failed";
-      return false;
-    }
-
     s.BindString16(0, entries[i].key().name());
     s.BindString16(1, entries[i].key().value());
+
+    if (!s.is_valid())
+      return false;
+
     if (s.Step()) {
       if (!RemoveFormElementForID(s.ColumnInt64(0)))
         return false;
     }
   }
 
   // Insert all the supplied autofill entries.
   for (size_t i = 0; i < entries.size(); i++) {
     if (!InsertAutofillEntry(entries[i]))
       return false;
   }
 
   return true;
 }
 
 bool AutofillTable::InsertAutofillEntry(const AutofillEntry& entry) {
   std::string sql = "INSERT INTO autofill (name, value, value_lower, count) "
                     "VALUES (?, ?, ?, ?)";
   sql::Statement s(db_->GetUniqueStatement(sql.c_str()));
-  if (!s.is_valid()) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
-
   s.BindString16(0, entry.key().name());
   s.BindString16(1, entry.key().value());
   s.BindString16(2, base::i18n::ToLower(entry.key().value()));
   s.BindInt(3, entry.timestamps().size());
 
-  if (!s.Run()) {
-    NOTREACHED();
+  if (!s.Run())
     return false;
-  }
 
   int64 pair_id = db_->GetLastInsertRowId();
   for (size_t i = 0; i < entry.timestamps().size(); i++) {
     if (!InsertPairIDAndDate(pair_id, entry.timestamps()[i]))
       return false;
   }
 
   return true;
 }
 
@@ skipping 22 matching lines @@
                      AutofillKey(element.name, element.value)));
   return true;
 }
 
 
 bool AutofillTable::RemoveFormElement(const string16& name,
                                       const string16& value) {
   // Find the id for that pair.
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT pair_id FROM autofill WHERE  name = ? AND value= ?"));
-  if (!s) {
-    NOTREACHED() << "Statement 1 prepare failed";
-    return false;
-  }
   s.BindString16(0, name);
   s.BindString16(1, value);
 
   if (s.Step())
     return RemoveFormElementForID(s.ColumnInt64(0));
   return false;
 }
 
 bool AutofillTable::AddAutofillProfile(const AutofillProfile& profile) {
   if (IsAutofillGUIDInTrash(profile.guid()))
     return true;
 
   sql::Statement s(db_->GetUniqueStatement(
       "INSERT INTO autofill_profiles"
       "(guid, company_name, address_line_1, address_line_2, city, state,"
       " zipcode, country, country_code, date_modified)"
       "VALUES (?,?,?,?,?,?,?,?,?,?)"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
-
   BindAutofillProfileToStatement(profile, &s);
 
-  if (!s.Run()) {
-    NOTREACHED();
-    return false;
-  }
-
-  if (!s.Succeeded())
+  if (!s.Run())
     return false;
 
   return AddAutofillProfilePieces(profile, db_);
 }
 
 bool AutofillTable::GetAutofillProfile(const std::string& guid,
                                        AutofillProfile** profile) {
   DCHECK(guid::IsValidGUID(guid));
   DCHECK(profile);
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT guid, company_name, address_line_1, address_line_2, city, state,"
       " zipcode, country, country_code, date_modified "
       "FROM autofill_profiles "
       "WHERE guid=?"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
+  s.BindString(0, guid);
 
-  s.BindString(0, guid);
   if (!s.Step())
     return false;
 
-  if (!s.Succeeded())
-    return false;
-
   scoped_ptr<AutofillProfile> p(AutofillProfileFromStatement(s));
 
   // Get associated name info.
   AddAutofillProfileNamesToProfile(db_, p.get());
 
   // Get associated email info.
   AddAutofillProfileEmailsToProfile(db_, p.get());
 
   // Get associated phone info.
   AddAutofillProfilePhonesToProfile(db_, p.get());
 
   *profile = p.release();
   return true;
 }
 
 bool AutofillTable::GetAutofillProfiles(
     std::vector<AutofillProfile*>* profiles) {
   DCHECK(profiles);
   profiles->clear();
 
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT guid "
       "FROM autofill_profiles"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
 
   while (s.Step()) {
     std::string guid = s.ColumnString(0);
     AutofillProfile* profile = NULL;
     if (!GetAutofillProfile(guid, &profile))
       return false;
     profiles->push_back(profile);
   }
 
   return s.Succeeded();
@@ skipping 50 matching lines @@
   scoped_ptr<AutofillProfile> old_profile(tmp_profile);
   if (old_profile->CompareMulti(profile) == 0)
     return true;
 
   sql::Statement s(db_->GetUniqueStatement(
       "UPDATE autofill_profiles "
       "SET guid=?, company_name=?, address_line_1=?, address_line_2=?, "
       "    city=?, state=?, zipcode=?, country=?, country_code=?, "
       "    date_modified=? "
       "WHERE guid=?"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
-
   BindAutofillProfileToStatement(profile, &s);
   s.BindString(10, profile.guid());
+
   bool result = s.Run();
   DCHECK_GT(db_->GetLastChangeCount(), 0);
   if (!result)
     return result;
 
   // Remove the old names, emails, and phone numbers.
   if (!RemoveAutofillProfilePieces(profile.guid(), db_))
     return false;
 
   return AddAutofillProfilePieces(profile, db_);
 }
 
 bool AutofillTable::RemoveAutofillProfile(const std::string& guid) {
   DCHECK(guid::IsValidGUID(guid));
 
   if (IsAutofillGUIDInTrash(guid)) {
     sql::Statement s_trash(db_->GetUniqueStatement(
         "DELETE FROM autofill_profiles_trash WHERE guid = ?"));
-    if (!s_trash) {
-      NOTREACHED() << "Statement prepare failed";
-      return false;
-    }
     s_trash.BindString(0, guid);
-    if (!s_trash.Run()) {
-      NOTREACHED() << "Expected item in trash.";
-      return false;
-    }
 
-    return true;
+    bool success = s_trash.Run();
+    DCHECK_GT(db_->GetLastChangeCount(), 0) << "Expected item in trash";
+    return success;
   }
 
   sql::Statement s(db_->GetUniqueStatement(
       "DELETE FROM autofill_profiles WHERE guid = ?"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
+  s.BindString(0, guid);
 
-  s.BindString(0, guid);
   if (!s.Run())
     return false;
 
   return RemoveAutofillProfilePieces(guid, db_);
 }
 
 bool AutofillTable::ClearAutofillProfiles() {
   sql::Statement s1(db_->GetUniqueStatement(
       "DELETE FROM autofill_profiles"));
-  if (!s1) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
 
   if (!s1.Run())
     return false;
 
   sql::Statement s2(db_->GetUniqueStatement(
       "DELETE FROM autofill_profile_names"));
-  if (!s2) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
 
   if (!s2.Run())
     return false;
 
   sql::Statement s3(db_->GetUniqueStatement(
       "DELETE FROM autofill_profile_emails"));
-  if (!s3) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
 
   if (!s3.Run())
     return false;
 
   sql::Statement s4(db_->GetUniqueStatement(
       "DELETE FROM autofill_profile_phones"));
-  if (!s4) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
 
-  if (!s4.Run())
-    return false;
-
-  return true;
+  return s4.Run();
 }
 
 bool AutofillTable::AddCreditCard(const CreditCard& credit_card) {
   sql::Statement s(db_->GetUniqueStatement(
       "INSERT INTO credit_cards"
       "(guid, name_on_card, expiration_month, expiration_year, "
       "card_number_encrypted, date_modified)"
       "VALUES (?,?,?,?,?,?)"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
-
   BindCreditCardToStatement(credit_card, &s);
 
-  if (!s.Run()) {
-    NOTREACHED();
+  if (!s.Run())
     return false;
-  }
 
   DCHECK_GT(db_->GetLastChangeCount(), 0);
-  return s.Succeeded();
+  return true;
 }
 
 bool AutofillTable::GetCreditCard(const std::string& guid,
                                   CreditCard** credit_card) {
   DCHECK(guid::IsValidGUID(guid));
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT guid, name_on_card, expiration_month, expiration_year, "
       "card_number_encrypted, date_modified "
       "FROM credit_cards "
       "WHERE guid = ?"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
+  s.BindString(0, guid);
 
-  s.BindString(0, guid);
   if (!s.Step())
     return false;
 
   *credit_card = CreditCardFromStatement(s);
-
-  return s.Succeeded();
+  return true;
 }
 
 bool AutofillTable::GetCreditCards(
     std::vector<CreditCard*>* credit_cards) {
   DCHECK(credit_cards);
   credit_cards->clear();
 
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT guid "
       "FROM credit_cards"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
 
   while (s.Step()) {
     std::string guid = s.ColumnString(0);
     CreditCard* credit_card = NULL;
     if (!GetCreditCard(guid, &credit_card))
       return false;
     credit_cards->push_back(credit_card);
   }
 
   return s.Succeeded();
 }
 
 bool AutofillTable::UpdateCreditCard(const CreditCard& credit_card) {
   DCHECK(guid::IsValidGUID(credit_card.guid()));
 
   CreditCard* tmp_credit_card = NULL;
   if (!GetCreditCard(credit_card.guid(), &tmp_credit_card))
     return false;
 
   // Preserve appropriate modification dates by not updating unchanged cards.
   scoped_ptr<CreditCard> old_credit_card(tmp_credit_card);
   if (*old_credit_card == credit_card)
     return true;
 
   sql::Statement s(db_->GetUniqueStatement(
       "UPDATE credit_cards "
       "SET guid=?, name_on_card=?, expiration_month=?, "
       "    expiration_year=?, card_number_encrypted=?, date_modified=? "
       "WHERE guid=?"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
-
   BindCreditCardToStatement(credit_card, &s);
   s.BindString(6, credit_card.guid());
+
   bool result = s.Run();
   DCHECK_GT(db_->GetLastChangeCount(), 0);
   return result;
 }
 
 bool AutofillTable::RemoveCreditCard(const std::string& guid) {
   DCHECK(guid::IsValidGUID(guid));
   sql::Statement s(db_->GetUniqueStatement(
       "DELETE FROM credit_cards WHERE guid = ?"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
+  s.BindString(0, guid);
 
-  s.BindString(0, guid);
   return s.Run();
 }
 
 bool AutofillTable::RemoveAutofillProfilesAndCreditCardsModifiedBetween(
     const Time& delete_begin,
     const Time& delete_end,
     std::vector<std::string>* profile_guids,
     std::vector<std::string>* credit_card_guids) {
   DCHECK(delete_end.is_null() || delete_begin < delete_end);
 
   time_t delete_begin_t = delete_begin.ToTimeT();
   time_t delete_end_t = delete_end.is_null() ?
       std::numeric_limits<time_t>::max() :
       delete_end.ToTimeT();
 
   // Remember Autofill profiles in the time range.
   sql::Statement s_profiles_get(db_->GetUniqueStatement(
       "SELECT guid FROM autofill_profiles "
       "WHERE date_modified >= ? AND date_modified < ?"));
-  if (!s_profiles_get) {
-    NOTREACHED() << "Autofill profiles statement prepare failed";
-    return false;
-  }
-
   s_profiles_get.BindInt64(0, delete_begin_t);
   s_profiles_get.BindInt64(1, delete_end_t);
+
   profile_guids->clear();
   while (s_profiles_get.Step()) {
     std::string guid = s_profiles_get.ColumnString(0);
     profile_guids->push_back(guid);
   }
+  if (!s_profiles_get.Succeeded())
+    return false;

[Scott Hess - ex-Googler, 2011/12/16 22:37:09]

I think that, given that the caller already is committed to accepting the
clear() in case of a successful (but empty) result, having it cleared for a
failure seems reasonable.  That's the kind of subtle thing that the header
should document and unit tests should test, if it's expected.

[Greg Billock, 2011/12/21 21:43:03]

Added documentation for this. Checked caller; it is checking return value and
behaving OK in this case.

 
   // Remove Autofill profiles in the time range.
   sql::Statement s_profiles(db_->GetUniqueStatement(
       "DELETE FROM autofill_profiles "
       "WHERE date_modified >= ? AND date_modified < ?"));
-  if (!s_profiles) {
-    NOTREACHED() << "Autofill profiles statement prepare failed";
-    return false;
-  }
-
   s_profiles.BindInt64(0, delete_begin_t);
   s_profiles.BindInt64(1, delete_end_t);
-  s_profiles.Run();
 
-  if (!s_profiles.Succeeded()) {
-    NOTREACHED();
+  if (!s_profiles.Run())
     return false;
-  }
 
   // Remember Autofill credit cards in the time range.
   sql::Statement s_credit_cards_get(db_->GetUniqueStatement(
       "SELECT guid FROM credit_cards "
       "WHERE date_modified >= ? AND date_modified < ?"));
-  if (!s_credit_cards_get) {
-    NOTREACHED() << "Autofill profiles statement prepare failed";
-    return false;
-  }
-
   s_credit_cards_get.BindInt64(0, delete_begin_t);
   s_credit_cards_get.BindInt64(1, delete_end_t);
+
   credit_card_guids->clear();
   while (s_credit_cards_get.Step()) {
     std::string guid = s_credit_cards_get.ColumnString(0);
     credit_card_guids->push_back(guid);
   }
+  if (!s_credit_cards_get.Succeeded())
+    return false;
 
   // Remove Autofill credit cards in the time range.
   sql::Statement s_credit_cards(db_->GetUniqueStatement(
       "DELETE FROM credit_cards "
       "WHERE date_modified >= ? AND date_modified < ?"));
-  if (!s_credit_cards) {
-    NOTREACHED() << "Autofill credit cards statement prepare failed";
-    return false;
-  }
-
   s_credit_cards.BindInt64(0, delete_begin_t);
   s_credit_cards.BindInt64(1, delete_end_t);
-  s_credit_cards.Run();
 
-  if (!s_credit_cards.Succeeded()) {
-    NOTREACHED();
-    return false;
-  }
-
-  return true;
+  return s_credit_cards.Run();
 }
 
 bool AutofillTable::GetAutofillProfilesInTrash(
     std::vector<std::string>* guids) {
   guids->clear();
 
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT guid "
       "FROM autofill_profiles_trash"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
 
   while (s.Step()) {
     std::string guid = s.ColumnString(0);
     guids->push_back(guid);
   }
 
   return s.Succeeded();
 }
 
 bool AutofillTable::EmptyAutofillProfilesTrash() {
   sql::Statement s(db_->GetUniqueStatement(
       "DELETE FROM autofill_profiles_trash"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
 
   return s.Run();
 }
 
 
 bool AutofillTable::RemoveFormElementForID(int64 pair_id) {
   sql::Statement s(db_->GetUniqueStatement(
       "DELETE FROM autofill WHERE pair_id = ?"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
   s.BindInt64(0, pair_id);
+
   if (s.Run())
     return RemoveFormElementForTimeRange(pair_id, Time(), Time(), NULL);
 
   return false;
 }
 
 bool AutofillTable::AddAutofillGUIDToTrash(const std::string& guid) {
   sql::Statement s(db_->GetUniqueStatement(
     "INSERT INTO autofill_profiles_trash"
     " (guid) "
     "VALUES (?)"));
-  if (!s) {
-    NOTREACHED();
-    return sql::INIT_FAILURE;
-  }
+  s.BindString(0, guid);
 
-  s.BindString(0, guid);
-  if (!s.Run()) {
-    NOTREACHED();
-    return false;
-  }
-  return true;
+  return s.Run();
 }
 
 bool AutofillTable::IsAutofillProfilesTrashEmpty() {
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT guid "
       "FROM autofill_profiles_trash"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
 
   return !s.Step();
 }
 
 bool AutofillTable::IsAutofillGUIDInTrash(const std::string& guid) {
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT guid "
       "FROM autofill_profiles_trash "
       "WHERE guid = ?"));
-  if (!s) {
-    NOTREACHED() << "Statement prepare failed";
-    return false;
-  }
+  s.BindString(0, guid);
 
-  s.BindString(0, guid);
   return s.Step();
 }
 
 bool AutofillTable::InitMainTable() {
   if (!db_->DoesTableExist("autofill")) {
     if (!db_->Execute("CREATE TABLE autofill ("
                       "name VARCHAR, "
                       "value VARCHAR, "
                       "value_lower VARCHAR, "
                       "pair_id INTEGER PRIMARY KEY, "
@@ skipping 242 matching lines @@
         db_->DoesColumnExist("credit_cards", "billing_address") &&
         db_->DoesColumnExist("autofill_profiles", "unique_id"))) {
     return true;
   }
 
   std::string stmt =
       "SELECT credit_cards.unique_id, autofill_profiles.unique_id "
       "FROM autofill_profiles, credit_cards "
       "WHERE credit_cards.billing_address = autofill_profiles.label";
   sql::Statement s(db_->GetUniqueStatement(stmt.c_str()));
-  if (!s)
-    return false;
 
   std::map<int, int> cc_billing_map;
   while (s.Step())
     cc_billing_map[s.ColumnInt(0)] = s.ColumnInt(1);
+  if (!s.Succeeded())
+    return false;
 
   // Windows already stores the IDs as strings in |billing_address|. Try
   // to convert those.
   if (cc_billing_map.empty()) {
     std::string stmt = "SELECT unique_id,billing_address FROM credit_cards";
     sql::Statement s(db_->GetUniqueStatement(stmt.c_str()));
-    if (!s)
-      return false;
 
     while (s.Step()) {
       int id = 0;
       if (base::StringToInt(s.ColumnString(1), &id))
         cc_billing_map[s.ColumnInt(0)] = id;
     }
+    if (!s.Succeeded())
+      return false;
   }
 
   if (!db_->Execute("CREATE TABLE credit_cards_temp ( "
                     "label VARCHAR, "
                     "unique_id INTEGER PRIMARY KEY, "
                     "name_on_card VARCHAR, "
                     "type VARCHAR, "
                     "card_number VARCHAR, "
                     "expiration_month INTEGER, "
                     "expiration_year INTEGER, "
@@ skipping 18 matching lines @@
     return false;
 
   if (!db_->Execute("ALTER TABLE credit_cards_temp RENAME TO credit_cards"))
     return false;
 
   for (std::map<int, int>::const_iterator iter = cc_billing_map.begin();
        iter != cc_billing_map.end(); ++iter) {
     sql::Statement s(db_->GetCachedStatement(
         SQL_FROM_HERE,
         "UPDATE credit_cards SET billing_address=? WHERE unique_id=?"));
-    if (!s)
-      return false;
-
     s.BindInt(0, (*iter).second);
     s.BindInt(1, (*iter).first);
 
     if (!s.Run())
       return false;
   }
 
   return true;
 }
 
 bool AutofillTable::MigrateToVersion30AddDateModifed() {
   // Add date_modified to autofill_profiles.
   if (!db_->DoesColumnExist("autofill_profiles", "date_modified")) {
     if (!db_->Execute("ALTER TABLE autofill_profiles ADD COLUMN "
                       "date_modified INTEGER NON NULL DEFAULT 0")) {
       return false;
     }
 
     sql::Statement s(db_->GetUniqueStatement(
         "UPDATE autofill_profiles SET date_modified=?"));
-    if (!s)
-      return false;
-
     s.BindInt64(0, Time::Now().ToTimeT());
 
     if (!s.Run())
       return false;
   }
 
   // Add date_modified to credit_cards.
   if (!db_->DoesColumnExist("credit_cards", "date_modified")) {
     if (!db_->Execute("ALTER TABLE credit_cards ADD COLUMN "
                       "date_modified INTEGER NON NULL DEFAULT 0")) {
       return false;
     }
 
     sql::Statement s(db_->GetUniqueStatement(
         "UPDATE credit_cards SET date_modified=?"));
-    if (!s)
-      return false;
-
     s.BindInt64(0, Time::Now().ToTimeT());
 
     if (!s.Run())
       return false;
   }
 
   return true;
 }
 
 bool AutofillTable::MigrateToVersion31AddGUIDToCreditCardsAndProfiles() {
   // Note that we need to check for the guid column's existence due to the
   // fact that for a version 22 database the |autofill_profiles| table
   // gets created fresh with |InitAutofillProfilesTable|.
   if (!db_->DoesColumnExist("autofill_profiles", "guid")) {
     if (!db_->Execute("ALTER TABLE autofill_profiles ADD COLUMN "
                       "guid VARCHAR NOT NULL DEFAULT \"\"")) {
       return false;
     }
 
     // Set all the |guid| fields to valid values.
 
     sql::Statement s(db_->GetUniqueStatement("SELECT unique_id "
                                              "FROM autofill_profiles"));
-    if (!s)
-      return false;
 
     while (s.Step()) {
       sql::Statement update_s(
           db_->GetUniqueStatement("UPDATE autofill_profiles "
                                   "SET guid=? WHERE unique_id=?"));
-      if (!update_s)
-        return false;
       update_s.BindString(0, guid::GenerateGUID());
       update_s.BindInt(1, s.ColumnInt(0));
 
       if (!update_s.Run())
         return false;
     }
+    if (!s.Succeeded())
+      return false;
   }
 
   // Note that we need to check for the guid column's existence due to the
   // fact that for a version 22 database the |autofill_profiles| table
   // gets created fresh with |InitAutofillProfilesTable|.
   if (!db_->DoesColumnExist("credit_cards", "guid")) {
     if (!db_->Execute("ALTER TABLE credit_cards ADD COLUMN "
                       "guid VARCHAR NOT NULL DEFAULT \"\"")) {
       return false;
     }
 
     // Set all the |guid| fields to valid values.
 
     sql::Statement s(db_->GetUniqueStatement("SELECT unique_id "
                                              "FROM credit_cards"));
-    if (!s)
-      return false;
 
     while (s.Step()) {
       sql::Statement update_s(
           db_->GetUniqueStatement("UPDATE credit_cards "
                                   "set guid=? WHERE unique_id=?"));
-      if (!update_s)
-        return false;
       update_s.BindString(0, guid::GenerateGUID());
       update_s.BindInt(1, s.ColumnInt(0));
 
       if (!update_s.Run())
         return false;
     }
+    if (!s.Succeeded())
+      return false;
   }
 
   return true;
 }
 
 bool AutofillTable::MigrateToVersion32UpdateProfilesAndCreditCards() {
   if (db_->DoesColumnExist("autofill_profiles", "unique_id")) {
     if (!db_->Execute("CREATE TABLE autofill_profiles_temp ( "
                       "guid VARCHAR PRIMARY KEY, "
                       "label VARCHAR, "
@@ skipping 81 matching lines @@
                         "date_modified INTEGER NOT NULL DEFAULT 0)")) {
         return false;
       }
     }
 
     sql::Statement s(db_->GetUniqueStatement(
         "SELECT guid, first_name, middle_name, last_name, email, "
         "company_name, address_line_1, address_line_2, city, state, "
         "zipcode, country, phone, date_modified "
         "FROM autofill_profiles"));
+
     while (s.Step()) {
       AutofillProfile profile;
       profile.set_guid(s.ColumnString(0));
       DCHECK(guid::IsValidGUID(profile.guid()));
 
       profile.SetInfo(NAME_FIRST, s.ColumnString16(1));
       profile.SetInfo(NAME_MIDDLE, s.ColumnString16(2));
       profile.SetInfo(NAME_LAST, s.ColumnString16(3));
       profile.SetInfo(EMAIL_ADDRESS, s.ColumnString16(4));
       profile.SetInfo(COMPANY_NAME, s.ColumnString16(5));
       profile.SetInfo(ADDRESS_HOME_LINE1, s.ColumnString16(6));
       profile.SetInfo(ADDRESS_HOME_LINE2, s.ColumnString16(7));
       profile.SetInfo(ADDRESS_HOME_CITY, s.ColumnString16(8));
       profile.SetInfo(ADDRESS_HOME_STATE, s.ColumnString16(9));
       profile.SetInfo(ADDRESS_HOME_ZIP, s.ColumnString16(10));
       profile.SetInfo(ADDRESS_HOME_COUNTRY, s.ColumnString16(11));
       profile.SetInfo(PHONE_HOME_WHOLE_NUMBER, s.ColumnString16(12));
       int64 date_modified = s.ColumnInt64(13);
 
       sql::Statement s_insert(db_->GetUniqueStatement(
           "INSERT INTO autofill_profiles_temp"
           "(guid, company_name, address_line_1, address_line_2, city,"
           " state, zipcode, country, date_modified)"
           "VALUES (?,?,?,?,?,?,?,?,?)"));
-      if (!s)
-        return false;
-
       s_insert.BindString(0, profile.guid());
       s_insert.BindString16(1, profile.GetInfo(COMPANY_NAME));
       s_insert.BindString16(2, profile.GetInfo(ADDRESS_HOME_LINE1));
       s_insert.BindString16(3, profile.GetInfo(ADDRESS_HOME_LINE2));
       s_insert.BindString16(4, profile.GetInfo(ADDRESS_HOME_CITY));
       s_insert.BindString16(5, profile.GetInfo(ADDRESS_HOME_STATE));
       s_insert.BindString16(6, profile.GetInfo(ADDRESS_HOME_ZIP));
       s_insert.BindString16(7, profile.GetInfo(ADDRESS_HOME_COUNTRY));
       s_insert.BindInt64(8, date_modified);
 
       if (!s_insert.Run())
         return false;
 
       // Add the other bits: names, emails, and phone numbers.
       if (!AddAutofillProfilePieces(profile, db_))
         return false;
-    }
+    }  // endwhile
+    if (!s.Succeeded())
+      return false;
 
     if (!db_->Execute("DROP TABLE autofill_profiles"))
       return false;
 
     if (!db_->Execute(
         "ALTER TABLE autofill_profiles_temp RENAME TO autofill_profiles")) {
       return false;
     }
   }
 
@@ skipping 35 matching lines @@
   if (!db_->DoesColumnExist("autofill_profiles", "country_code")) {
     if (!db_->Execute("ALTER TABLE autofill_profiles ADD COLUMN "
                       "country_code VARCHAR")) {
       return false;
     }
 
     // Set all the |country_code| fields to match existing |country| values.
     sql::Statement s(db_->GetUniqueStatement("SELECT guid, country "
                                              "FROM autofill_profiles"));
 
-    if (!s)
-      return false;
-
     while (s.Step()) {
       sql::Statement update_s(
           db_->GetUniqueStatement("UPDATE autofill_profiles "
                                   "SET country_code=? WHERE guid=?"));
-      if (!update_s)
-        return false;
 
       string16 country = s.ColumnString16(1);
       std::string app_locale = AutofillCountry::ApplicationLocale();
       update_s.BindString(0, AutofillCountry::GetCountryCode(country,
                                                              app_locale));
       update_s.BindString(1, s.ColumnString(0));
 
       if (!update_s.Run())
         return false;
     }
+    if (!s.Succeeded())
+      return false;
   }
 
   return true;
 }
 
 // Correct all country codes with value "UK" to be "GB".  This data
 // was mistakenly introduced in build 686.0.  This migration is to clean
 // it up.  See http://crbug.com/74511 for details.
 bool AutofillTable::MigrateToVersion35GreatBritainCountryCodes() {
   sql::Statement s(db_->GetUniqueStatement(
       "UPDATE autofill_profiles SET country_code=\"GB\" "
       "WHERE country_code=\"UK\""));
 
   return s.Run();
 }
 
 // Merge and cull older profiles where possible.
 bool AutofillTable::MigrateToVersion37MergeAndCullOlderProfiles() {
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT guid, date_modified FROM autofill_profiles"));
-  if (!s)
-    return false;
 
   // Accumulate the good profiles.
   std::vector<AutofillProfile> accumulated_profiles;
   std::vector<AutofillProfile*> accumulated_profiles_p;
   std::map<std::string, int64> modification_map;
   while (s.Step()) {
     std::string guid = s.ColumnString(0);
     int64 date_modified = s.ColumnInt64(1);
     modification_map.insert(
         std::pair<std::string, int64>(guid, date_modified));
@@ skipping 18 matching lines @@
                      address_of<AutofillProfile>);
 
       // If the profile got merged trash the original.
       if (merged)
         AddAutofillGUIDToTrash(p->guid());
 
     } else {
       // An invalid profile, so trash it.
       AddAutofillGUIDToTrash(p->guid());
     }
-  }
+  }  // endwhile
+  if (!s.Succeeded())
+    return false;
 
   // Drop the current profiles.
   if (!ClearAutofillProfiles())
     return false;
 
   // Add the newly merged profiles back in.
   for (std::vector<AutofillProfile>::const_iterator
           iter = accumulated_profiles.begin();
        iter != accumulated_profiles.end();
        ++iter) {
     if (!AddAutofillProfile(*iter))
       return false;
 
     // Fix up the original modification date.
     std::map<std::string, int64>::const_iterator date_item =
         modification_map.find(iter->guid());
     if (date_item == modification_map.end())
       return false;
 
     sql::Statement s_date(db_->GetUniqueStatement(
         "UPDATE autofill_profiles SET date_modified=? "
         "WHERE guid=?"));
     s_date.BindInt64(0, date_item->second);
     s_date.BindString(1, iter->guid());
+
     if (!s_date.Run())
       return false;
   }
 
   return true;
 }