Use higher precision to store the login database's date_created field.

components/password_manager/core/browser/login_database.cc

 // Copyright 2014 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 "components/password_manager/core/browser/login_database.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/pickle.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/password_manager/core/browser/password_manager_client.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "sql/connection.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 
 using autofill::PasswordForm;
 
 namespace password_manager {
 
-static const int kCurrentVersionNumber = 8;
+static const int kCurrentVersionNumber = 9;
 static const int kCompatibleVersionNumber = 1;
 
 Pickle SerializeVector(const std::vector<base::string16>& vec) {
   Pickle p;
   for (size_t i = 0; i < vec.size(); ++i) {
     p.WriteString16(vec[i]);
   }
   return p;
 }
 
@@ skipping 43 matching lines @@
   s->BindString(COLUMN_ACTION_URL, form.action.spec());
   s->BindString16(COLUMN_USERNAME_ELEMENT, form.username_element);
   s->BindString16(COLUMN_USERNAME_VALUE, form.username_value);
   s->BindString16(COLUMN_PASSWORD_ELEMENT, form.password_element);
   s->BindBlob(COLUMN_PASSWORD_VALUE, encrypted_password.data(),
               static_cast<int>(encrypted_password.length()));
   s->BindString16(COLUMN_SUBMIT_ELEMENT, form.submit_element);
   s->BindString(COLUMN_SIGNON_REALM, form.signon_realm);
   s->BindInt(COLUMN_SSL_VALID, form.ssl_valid);
   s->BindInt(COLUMN_PREFERRED, form.preferred);
-  s->BindInt64(COLUMN_DATE_CREATED, form.date_created.ToTimeT());
+  s->BindInt64(COLUMN_DATE_CREATED, form.date_created.ToInternalValue());
   s->BindInt(COLUMN_BLACKLISTED_BY_USER, form.blacklisted_by_user);
   s->BindInt(COLUMN_SCHEME, form.scheme);
   s->BindInt(COLUMN_PASSWORD_TYPE, form.type);
   Pickle usernames_pickle = SerializeVector(form.other_possible_usernames);
   s->BindBlob(COLUMN_POSSIBLE_USERNAMES,
               usernames_pickle.data(),
               usernames_pickle.size());
   s->BindInt(COLUMN_TIMES_USED, form.times_used);
   Pickle form_data_pickle;
   autofill::SerializeFormData(form.form_data, &form_data_pickle);
@@ skipping 145 matching lines @@
       }
       meta_table_.SetVersionNumber(7);
       // Fall through.
     case 7:
       // Keep version 8 around even though no changes are made. See
       // crbug.com/423716 for context.
       meta_table_.SetVersionNumber(8);
       // Fall through.
       // TODO(gcasto): Remove use_additional_auth by copying table.
       // https://www.sqlite.org/lang_altertable.html
+    case 8: {
+      sql::Statement s;
+      s.Assign(db_.GetCachedStatement(SQL_FROM_HERE,
+                                      "UPDATE logins SET "
+                                      "date_created = "
+                                      "(date_created * ?)"));
+      s.BindInt64(0, base::Time::kMicrosecondsPerSecond);

[Garrett Casto, 2014/11/05 22:14:59]

It doesn't look like this is safe. Epoch for time_t isn't the same as for
base::Time(). I think that we need to round trip through base::Time() to be safe
(base::Time::FromTimeT().toInternalValue()).

[erikchen, 2014/11/06 01:35:01]

You're right. I updated the SQL statement to correctly perform the epoch change.

+      if (!s.Run())
+        return false;
+      meta_table_.SetVersionNumber(9);
+      // Fall through.
+    }
     case kCurrentVersionNumber:
       // Already up to date
       return true;
     default:
       NOTREACHED();
       return false;
   }
 }
 
 bool LoginDatabase::InitLoginsTable() {
@@ skipping 199 matching lines @@
   s.BindString(0, form.action.spec());
   s.BindBlob(1, encrypted_password.data(),
              static_cast<int>(encrypted_password.length()));
   s.BindInt(2, form.ssl_valid);
   s.BindInt(3, form.preferred);
   Pickle pickle = SerializeVector(form.other_possible_usernames);
   s.BindBlob(4, pickle.data(), pickle.size());
   s.BindInt(5, form.times_used);
   s.BindString16(6, form.submit_element);
   s.BindInt64(7, form.date_synced.ToInternalValue());
-  s.BindInt64(8, form.date_created.ToTimeT());
+  s.BindInt64(8, form.date_created.ToInternalValue());
   s.BindInt(9, form.blacklisted_by_user);
   s.BindInt(10, form.scheme);
   s.BindInt(11, form.type);
   s.BindString16(12, form.display_name);
   s.BindString(13, form.avatar_url.spec());
   s.BindString(14, form.federation_url.spec());
   s.BindInt(15, form.is_zero_click);
 
   // WHERE starts here.
   s.BindString(16, form.origin.spec());
@@ skipping 30 matching lines @@
   s.BindString(5, form.signon_realm);
 
   return s.Run();
 }
 
 bool LoginDatabase::RemoveLoginsCreatedBetween(base::Time delete_begin,
                                                base::Time delete_end) {
   sql::Statement s(db_.GetCachedStatement(SQL_FROM_HERE,
       "DELETE FROM logins WHERE "
       "date_created >= ? AND date_created < ?"));
-  s.BindInt64(0, delete_begin.ToTimeT());
+  s.BindInt64(0, delete_begin.ToInternalValue());
   s.BindInt64(1, delete_end.is_null() ? std::numeric_limits<int64>::max()
-                                      : delete_end.ToTimeT());
+                                      : delete_end.ToInternalValue());
 
   return s.Run();
 }
 
 bool LoginDatabase::RemoveLoginsSyncedBetween(base::Time delete_begin,
                                               base::Time delete_end) {
   sql::Statement s(db_.GetCachedStatement(
       SQL_FROM_HERE,
       "DELETE FROM logins WHERE date_synced >= ? AND date_synced < ?"));
   s.BindInt64(0, delete_begin.ToInternalValue());
@@ skipping 21 matching lines @@
   form->action = GURL(tmp);
   form->username_element = s.ColumnString16(COLUMN_USERNAME_ELEMENT);
   form->username_value = s.ColumnString16(COLUMN_USERNAME_VALUE);
   form->password_element = s.ColumnString16(COLUMN_PASSWORD_ELEMENT);
   form->password_value = decrypted_password;
   form->submit_element = s.ColumnString16(COLUMN_SUBMIT_ELEMENT);
   tmp = s.ColumnString(COLUMN_SIGNON_REALM);
   form->signon_realm = tmp;
   form->ssl_valid = (s.ColumnInt(COLUMN_SSL_VALID) > 0);
   form->preferred = (s.ColumnInt(COLUMN_PREFERRED) > 0);
-  form->date_created = base::Time::FromTimeT(
-      s.ColumnInt64(COLUMN_DATE_CREATED));
+  form->date_created =
+      base::Time::FromInternalValue(s.ColumnInt64(COLUMN_DATE_CREATED));
   form->blacklisted_by_user = (s.ColumnInt(COLUMN_BLACKLISTED_BY_USER) > 0);
   int scheme_int = s.ColumnInt(COLUMN_SCHEME);
   DCHECK((scheme_int >= 0) && (scheme_int <= PasswordForm::SCHEME_OTHER));
   form->scheme = static_cast<PasswordForm::Scheme>(scheme_int);
   int type_int = s.ColumnInt(COLUMN_PASSWORD_TYPE);
   DCHECK(type_int >= 0 && type_int <= PasswordForm::TYPE_GENERATED);
   form->type = static_cast<PasswordForm::Type>(type_int);
   if (s.ColumnByteLength(COLUMN_POSSIBLE_USERNAMES)) {
     Pickle pickle(
         static_cast<const char*>(s.ColumnBlob(COLUMN_POSSIBLE_USERNAMES)),
@@ skipping 118 matching lines @@
   sql::Statement s(db_.GetCachedStatement(SQL_FROM_HERE,
       "SELECT origin_url, action_url, "
       "username_element, username_value, "
       "password_element, password_value, submit_element, "
       "signon_realm, ssl_valid, preferred, date_created, blacklisted_by_user, "
       "scheme, password_type, possible_usernames, times_used, form_data, "
       "date_synced, display_name, avatar_url, "
       "federation_url, is_zero_click FROM logins "
       "WHERE date_created >= ? AND date_created < ?"
       "ORDER BY origin_url"));
-  s.BindInt64(0, begin.ToTimeT());
+  s.BindInt64(0, begin.ToInternalValue());
   s.BindInt64(1, end.is_null() ? std::numeric_limits<int64>::max()
-                               : end.ToTimeT());
+                               : end.ToInternalValue());
 
   while (s.Step()) {
     scoped_ptr<PasswordForm> new_form(new PasswordForm());
     EncryptionResult result = InitPasswordFormFromStatement(new_form.get(), s);
     if (result == ENCRYPTION_RESULT_SERVICE_FAILURE)
       return false;
     if (result == ENCRYPTION_RESULT_ITEM_FAILURE)
       continue;
     DCHECK(result == ENCRYPTION_RESULT_SUCCESS);
     forms->push_back(new_form.release());
@@ skipping 74 matching lines @@
 
 bool LoginDatabase::DeleteAndRecreateDatabaseFile() {
   DCHECK(db_.is_open());
   meta_table_.Reset();
   db_.Close();
   sql::Connection::Delete(db_path_);
   return Init(db_path_);
 }
 
 }  // namespace password_manager