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));
   }
   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));
   }
   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()) {

[Scott Hess - ex-Googler, 2011/12/15 23:02:57]

Step() could return false either because it has reached the end of the results,
or because there was an error fetching the results.  In the error case, numbers
could be empty (if there was corruption accessing an index), or partially-filled
(if there was a corruption reading from the table).  Should these cases be
paying attention to Succeeded() before calling mutating functions?

[Greg Billock, 2011/12/16 17:26:58]

If it returns false we'll exit the loop, right? But if there's an error, it
should return false. So return s.Succeeded() is the correct behavior here.
Setting the value in that case is a bit cheeky. I'll edit around that...

OK, I've changed quite a few locations. Mostly to move is_valid() checks down
below and do Succeeded() checks. Those are more robust and WLOG. There is a
subtle behavior change, in that some of these will then zero out outparams
whereas before they'd leave them untouched. I'm inclined to believe this will be
OK, but do you think we need to examine that more carefully?

     DCHECK_EQ(profile->guid(), s.ColumnString(0));
     numbers.push_back(s.ColumnString16(2));
   }
   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));
 
   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.is_valid())
+    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.";

[Scott Hess - ex-Googler, 2011/12/15 23:02:57]

This looks like they might have originally meant
DCHECK_GT(db_->GetLastChangeCount(), 0);

[Greg Billock, 2011/12/16 17:26:58]

Added. I think you're right.

-      return false;
-    }
 
-    return true;
+    return s_trash.Run();
   }
 
   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);
+
+  if (!s_profiles_get.is_valid())
+    return false;
+
   profile_guids->clear();
   while (s_profiles_get.Step()) {
     std::string guid = s_profiles_get.ColumnString(0);
     profile_guids->push_back(guid);
   }
 
   // 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);
+
+  if (!s_profiles.is_valid())
+    return false;
+
   s_profiles.Run();
-
-  if (!s_profiles.Succeeded()) {
-    NOTREACHED();
+  if (!s_profiles.Succeeded())
     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);
+
+  if (!s_credit_cards_get.is_valid())
+    return false;
+
   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);
   }
 
   // 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);
+
+  if (!s_credit_cards.is_valid())
+    return false;
+
   s_credit_cards.Run();
-
-  if (!s_credit_cards.Succeeded()) {
-    NOTREACHED();
-    return false;
-  }
-
-  return true;
+  return s_credit_cards.Succeeded();
 }
 
 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;

[Scott Hess - ex-Googler, 2011/12/15 23:02:57]

I wish this hadn't compiled in the first place ...

-  }
+  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)
+  if (!s.is_valid())
     return false;
 
   std::map<int, int> cc_billing_map;
   while (s.Step())
     cc_billing_map[s.ColumnInt(0)] = s.ColumnInt(1);
 
   // 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)
+    if (!s.is_valid())
       return false;
 
     while (s.Step()) {
       int id = 0;
       if (base::StringToInt(s.ColumnString(1), &id))
         cc_billing_map[s.ColumnInt(0)] = id;
     }
   }
 
   if (!db_->Execute("CREATE TABLE credit_cards_temp ( "
@@ skipping 25 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)
+    if (!s.is_valid())
       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;
     }
   }
 
   // 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)
+    if (!s.is_valid())
       return false;
 
     while (s.Step()) {
       sql::Statement update_s(
           db_->GetUniqueStatement("UPDATE credit_cards "
                                   "set guid=? WHERE unique_id=?"));
-      if (!update_s)
+      if (!update_s.is_valid())
         return false;

[Scott Hess - ex-Googler, 2011/12/15 23:02:57]

Could be removed?

[Greg Billock, 2011/12/16 17:26:58]

Done.

       update_s.BindString(0, guid::GenerateGUID());
       update_s.BindInt(1, s.ColumnInt(0));
 
       if (!update_s.Run())
         return false;
     }
   }
 
   return true;
 }
@@ skipping 87 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);
 
@@ skipping 52 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)
+    if (!s.is_valid())
       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;
     }
@@ skipping 10 matching lines @@
       "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)
+  if (!s.is_valid())
     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(
@@ skipping 44 matching lines @@
     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;
 }