Web Intents: Hook up the register intent InfoBar with the WebIntentsRegistry.

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 386 matching lines @@
   return true;
 }
 
 bool AutofillTable::AddFormFieldValues(const std::vector<FormField>& elements,
                                        std::vector<AutofillChange>* changes) {
   return AddFormFieldValuesTime(elements, changes, Time::Now());
 }
 
 bool AutofillTable::AddFormFieldValue(const FormField& element,
                                       std::vector<AutofillChange>* changes) {
-  return AddFormFieldValueTime(element, changes, base::Time::Now());
+  return AddFormFieldValueTime(element, changes, Time::Now());
 }
 
 bool AutofillTable::GetFormValuesForElementName(const string16& name,
                                                 const string16& prefix,
                                                 std::vector<string16>* values,
                                                 int limit) {
   DCHECK(values);
   sql::Statement s;
 
   if (prefix.empty()) {
@@ skipping 32 matching lines @@
     s.BindInt(3, limit);
   }
 
   values->clear();
   while (s.Step())
     values->push_back(s.ColumnString16(0));
   return s.Succeeded();
 }
 
 bool AutofillTable::RemoveFormElementsAddedBetween(
-    base::Time delete_begin,
-    base::Time delete_end,
+    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";
@@ skipping 30 matching lines @@
     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,
+                                                  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());
@@ skipping 105 matching lines @@
   if (!s.Run()) {
     NOTREACHED();
     return false;
   }
 
   *pair_id = db_->GetLastInsertRowId();
   return true;
 }
 
 bool AutofillTable::InsertPairIDAndDate(int64 pair_id,
-                                        base::Time date_created) {
+                                        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;
 }
 
 bool AutofillTable::AddFormFieldValuesTime(
     const std::vector<FormField>& elements,
     std::vector<AutofillChange>* changes,
-    base::Time time) {
+    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)
@@ skipping 34 matching lines @@
       "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<base::Time>* timestamps_ptr = NULL;
+  std::vector<Time>* timestamps_ptr = NULL;
   string16 name, value;
-  base::Time time;
+  Time time;
   while (s.Step()) {
     name = s.ColumnString16(0);
     value = s.ColumnString16(1);
     time = Time::FromTimeT(s.ColumnInt64(2));
 
     if (first_entry) {
       current_key_ptr = new AutofillKey(name, value);
 
-      timestamps_ptr = new std::vector<base::Time>;
+      timestamps_ptr = new std::vector<Time>;
       timestamps_ptr->push_back(time);
 
       first_entry = false;
     } else {
       // we've encountered the next entry
       if (current_key_ptr->name().compare(name) != 0 ||
           current_key_ptr->value().compare(value) != 0) {
         AutofillEntry entry(*current_key_ptr, *timestamps_ptr);
         entries->push_back(entry);
 
         delete current_key_ptr;
         delete timestamps_ptr;
 
         current_key_ptr = new AutofillKey(name, value);
-        timestamps_ptr = new std::vector<base::Time>;
+        timestamps_ptr = new std::vector<Time>;
       }
       timestamps_ptr->push_back(time);
     }
   }
   // 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<base::Time>* timestamps) {
+                                          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;
   }
@@ skipping 62 matching lines @@
   for (size_t i = 0; i < entry.timestamps().size(); i++) {
     if (!InsertPairIDAndDate(pair_id, entry.timestamps()[i]))
       return false;
   }
 
   return true;
 }
 
 bool AutofillTable::AddFormFieldValueTime(const FormField& element,
                                           std::vector<AutofillChange>* changes,
-                                          base::Time time) {
+                                          Time time) {
   int count = 0;
   int64 pair_id;
 
   if (!GetIDAndCountOfFormElement(element, &pair_id, &count))
     return false;
 
   if (count == 0 && !InsertFormElement(element, &pair_id))
     return false;
 
   if (!SetCountOfFormElement(pair_id, count + 1))
@@ skipping 380 matching lines @@
   if (!s) {
     NOTREACHED() << "Statement prepare failed";
     return false;
   }
 
   s.BindString(0, guid);
   return s.Run();
 }
 
 bool AutofillTable::RemoveAutofillProfilesAndCreditCardsModifiedBetween(
-    base::Time delete_begin,
-    base::Time delete_end,
+    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.
@@ skipping 102 matching lines @@
 
 
 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, base::Time(), base::Time(),
-                                         NULL);
-  }
+  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();
@@ skipping 769 matching lines @@
         "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;
 }