Don't store empty values for autofill

chrome/browser/webdata/web_database.cc

 // Copyright (c) 2006-2008 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/web_database.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
@@ skipping 87 matching lines @@
 //
 // web_apps
 //   url                 URL of the web app.
 //   has_all_images      Do we have all the images?
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 using base::Time;
 
 // Current version number.
-static const int kCurrentVersionNumber = 21;
+static const int kCurrentVersionNumber = 22;
 static const int kCompatibleVersionNumber = 21;
 
 // Keys used in the meta table.
 static const char* kDefaultSearchProviderKey = "Default Search Provider ID";
 static const char* kBuiltinKeywordVersion = "Builtin Keyword Version";
 
 std::string JoinStrings(const std::string& separator,
                         const std::vector<std::string>& strings) {
   if (strings.empty())
     return std::string();
@@ skipping 720 matching lines @@
   bool result = true;
   for (std::vector<AutofillForm::Element>::const_iterator
        itr = elements.begin();
        itr != elements.end();
        itr++) {
     result = result && AddAutofillFormElement(*itr);
   }
   return result;
 }
 
+bool WebDatabase::ClearAutofillEmptyValueElements() {
+  SQLStatement s;
+
+  if (s.prepare(db_, "SELECT pair_id FROM autofill "
+                     "WHERE TRIM(value)= \"\"") != SQLITE_OK) {
+    NOTREACHED() << "Statement prepare failed";
+    return false;
+  }
+
+  std::set<int64> ids;
+  int result;
+  while ((result = s.step()) == SQLITE_ROW)
+    ids.insert(s.column_int64(0));
+
+  bool success = true;
+  for (std::set<int64>::const_iterator iter = ids.begin(); iter != ids.end();
+       ++iter) {
+    if (!RemoveFormElement(*iter)) 
+      success = false;
+  }
+  
+  return success;
+}
+
 bool WebDatabase::GetIDAndCountOfFormElement(
     const AutofillForm::Element& element, int64* pair_id, int* count) {
   SQLStatement s;
 
   if (s.prepare(db_, "SELECT pair_id, count FROM autofill "
                      " WHERE name = ? AND value = ?") != SQLITE_OK) {
     NOTREACHED() << "Statement prepare failed";
     return false;
   }
 
@@ skipping 188 matching lines @@
 
   if (result != SQLITE_DONE) {
     NOTREACHED();
     return false;
   }
 
   for (std::vector<int64>::iterator itr = pair_ids.begin();
        itr != pair_ids.end();
        itr++) {
     int how_many = 0;
-    if (!RemovePairIDAndDate(*itr, delete_begin, delete_end, &how_many))
+    if (!RemoveFormElementForTimeRange(*itr, delete_begin, delete_end,
+                                       &how_many)) {
       return false;
+    }
     if (!AddToCountOfFormElement(*itr, -how_many))
       return false;
   }
 
   return true;
 }
 
-bool WebDatabase::RemovePairIDAndDate(int64 pair_id, const Time delete_begin,
-    const Time delete_end, int* how_many) {
+bool WebDatabase::RemoveFormElementForTimeRange(int64 pair_id,
+                                                const Time delete_begin,
+                                                const Time delete_end,
+                                                int* how_many) {
   SQLStatement s;
   if (s.prepare(db_,
                 "DELETE FROM autofill_dates WHERE pair_id = ? AND "
                 "date_created >= ? AND date_created < ?") != SQLITE_OK) {
     NOTREACHED() << "Statement 1 prepare failed";
     return false;
   }
   s.bind_int64(0, pair_id);
-  s.bind_int64(1, delete_begin.ToTimeT());
-  s.bind_int64(2, 
-               delete_end.is_null() ?
-                   std::numeric_limits<int64>::max() :
-                   delete_end.ToTimeT());
+  s.bind_int64(1, delete_begin.is_null() ? 0 : delete_begin.ToTimeT());
+  s.bind_int64(2, delete_end.is_null() ? std::numeric_limits<int64>::max() :
+                                         delete_end.ToTimeT());
 
   bool result = (s.step() == SQLITE_DONE);
-  *how_many = sqlite3_changes(db_);
+  if (how_many)
+    *how_many = sqlite3_changes(db_);
 
   return result;
 }
 
 bool WebDatabase::AddToCountOfFormElement(int64 pair_id, int delta) {
   int count=0;
 
   if (!GetCountOfFormElement(pair_id, &count))
     return false;
 
   if (count + delta == 0) {
     if (!RemoveFormElement(pair_id))
       return false;
   } else {
     if (!SetCountOfFormElement(pair_id, count + delta))
       return false;
   }
   return true;
 }
 
 bool WebDatabase::RemoveFormElement(int64 pair_id) {
   SQLStatement s;
   if (s.prepare(db_,
                 "DELETE FROM autofill WHERE pair_id = ?") != SQLITE_OK) {
-    NOTREACHED() << "Statement 1 prepare failed";
+    NOTREACHED() << "Statement prepare failed";
     return false;
   }
   s.bind_int64(0, pair_id);
+  if (s.step() != SQLITE_DONE)
+    return false;
 
-  return (s.step() == SQLITE_DONE);
+  return RemoveFormElementForTimeRange(pair_id, Time(), Time(), NULL);
 }
 
 void WebDatabase::MigrateOldVersionsAsNeeded() {
   // Migrate if necessary.
   int current_version = meta_table_.GetVersionNumber();
   switch(current_version) {
     // Versions 1 - 19 are unhandled.  Version numbers greater than
     // kCurrentVersionNumber should have already been weeded out by the caller.
     default:
       // When the version is too old, we just try to continue anyway.  There
@@ skipping 10 matching lines @@
                        "INTEGER DEFAULT 0", NULL, NULL, NULL) != SQLITE_OK) {
         NOTREACHED();
         LOG(WARNING) << "Unable to update web database to version 21.";
         return;
       }
       meta_table_.SetVersionNumber(21);
       meta_table_.SetCompatibleVersionNumber(
           std::min(21, kCompatibleVersionNumber));
       // FALL THROUGH
 
+    case 21:
+      if (!ClearAutofillEmptyValueElements()) {
+        NOTREACHED() << "Failed to clean-up autofill DB.";
+      }
+      meta_table_.SetVersionNumber(22);
+      // No change in the compatibility version number.
+
+      // FALL THROUGH
+
     // Add successive versions here.  Each should set the version number and
     // compatible version number as appropriate, then fall through to the next
     // case.
 
     case kCurrentVersionNumber:
       // No migration needed.
       return;
   }
 }