[Sync] Log age of auth tokens on authentication failure

chrome/browser/signin/about_signin_internals.cc

 // Copyright (c) 2012 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/signin/about_signin_internals.h"
 
 #include "base/debug/trace_event.h"
 #include "base/hash.h"
 #include "base/i18n/time_formatting.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/signin_internals_util.h"
 #include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/signin/token_service.h"
 #include "chrome/browser/signin/token_service_factory.h"
 #include "chrome/browser/ui/webui/signin_internals_ui.h"
 #include "google_apis/gaia/gaia_constants.h"
 
 using namespace signin_internals_util;
 
+namespace {
+
+std::string TimeToFriendlyStr(base::Time time) {

[tim (not reviewing), 2013/05/03 00:46:43]

const& ?

[Nicolas Zea, 2013/05/03 01:31:41]

Done.

+  if (time.is_null())
+    return "";

[tim (not reviewing), 2013/05/03 00:46:43]

prefer std::string()

[Nicolas Zea, 2013/05/03 01:31:41]

Done.

+  return UTF16ToUTF8(base::TimeFormatFriendlyDate(time));
+}
+
+}  // namespace
+
 AboutSigninInternals::AboutSigninInternals() : profile_(NULL) {
   // Initialize default values for tokens.
   for (size_t i = 0; i < kNumTokenPrefs; ++i) {
     signin_status_.token_info_map.insert(std::pair<std::string, TokenInfo>(
         kTokenPrefsArray[i],
-        TokenInfo(
-            std::string(), "Not Loaded", std::string(), kTokenPrefsArray[i])));
+        TokenInfo("", "Not Loaded", "", 0, kTokenPrefsArray[i])));

[tim (not reviewing), 2013/05/03 00:46:43]

std::string() was a better choice than "".

[Nicolas Zea, 2013/05/03 01:31:41]

Done.

   }
 }
 
 AboutSigninInternals::~AboutSigninInternals() {
 }
 
 void AboutSigninInternals::AddSigninObserver(
     AboutSigninInternals::Observer* observer) {
   signin_observers_.AddObserver(observer);
 }
@@ skipping 19 matching lines @@
   NotifyObservers();
 }
 
 void AboutSigninInternals::NotifySigninValueChanged(
     const TimedSigninStatusField& field,
     const std::string& value) {
   unsigned int field_index = field - TIMED_FIELDS_BEGIN;
   DCHECK(field_index >= 0 &&
          field_index < signin_status_.timed_signin_fields.size());
 
-  std::string time_as_str = UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime(
-      base::Time::NowFromSystemTime()));
+  base::Time now = base::Time::NowFromSystemTime();

[tim (not reviewing), 2013/05/03 00:46:43]

nit - there's a whole pile of base::Times in here. Perhaps 'using base::Time'
would let you inline all of these to the TimeToFriendlyStr call?

[Nicolas Zea, 2013/05/03 01:31:41]

Done.

+  std::string time_as_str = TimeToFriendlyStr(now);
   TimedSigninStatusValue timed_value(value, time_as_str);
 
   signin_status_.timed_signin_fields[field_index] = timed_value;
 
   // Also persist these values in the prefs.
   const std::string value_pref = SigninStatusFieldToString(field) + ".value";
-  const std::string time_pref =  SigninStatusFieldToString(field) + ".time";
+  const std::string time_pref = SigninStatusFieldToString(field) + ".time";
   profile_->GetPrefs()->SetString(value_pref.c_str(), value);
   profile_->GetPrefs()->SetString(time_pref.c_str(), time_as_str);
 
   NotifyObservers();
 }
 
 void AboutSigninInternals::RefreshSigninPrefs() {
   // Return if no profile exists. Can occur in unit tests.
   if (!profile_)
     return;
@@ skipping 16 matching lines @@
                                  pref_service->GetString(time_pref.c_str()));
     signin_status_.timed_signin_fields[i - TIMED_FIELDS_BEGIN] = value;
   }
 
   // Get status and timestamps for all token services.
   for (size_t i = 0; i < kNumTokenPrefs; i++) {
     const std::string pref = TokenPrefPath(kTokenPrefsArray[i]);
     const std::string value = pref + ".value";
     const std::string status = pref + ".status";
     const std::string time = pref + ".time";
+    const std::string time_internal = pref + ".time_internal";

[tim (not reviewing), 2013/05/03 00:46:43]

What's with the local consts :P

[Nicolas Zea, 2013/05/03 01:31:41]

I was tempted to get rid of them!

 
     TokenInfo token_info(pref_service->GetString(value.c_str()),
                          pref_service->GetString(status.c_str()),
                          pref_service->GetString(time.c_str()),
+                         pref_service->GetInt64(time_internal.c_str()),
                          kTokenPrefsArray[i]);
 
     signin_status_.token_info_map[kTokenPrefsArray[i]] = token_info;
   }
 
   NotifyObservers();
 }
 
 void AboutSigninInternals::NotifyTokenReceivedSuccess(
     const std::string& token_name,
     const std::string& token,
     bool update_time) {
   // This should have been initialized already.
   DCHECK(signin_status_.token_info_map.count(token_name));
 
   const std::string status_success = "Successful";
   signin_status_.token_info_map[token_name].token = token;
   signin_status_.token_info_map[token_name].status = status_success;
 
   // Also update preferences.
   const std::string value_pref = TokenPrefPath(token_name) + ".value";
   const std::string time_pref = TokenPrefPath(token_name) + ".time";
+  const std::string time_internal_pref =
+      TokenPrefPath(token_name) + ".time_internal";
   const std::string status_pref = TokenPrefPath(token_name) + ".status";
   profile_->GetPrefs()->SetString(value_pref.c_str(), token);
   profile_->GetPrefs()->SetString(status_pref.c_str(), "Successful");
 
   // Update timestamp if needed.
   if (update_time) {
-    const std::string time_as_str = UTF16ToUTF8(
-        base::TimeFormatFriendlyDateAndTime(base::Time::NowFromSystemTime()));
+    base::Time now = base::Time::NowFromSystemTime();
+    int64 time_as_int = now.ToInternalValue();
+    const std::string time_as_str = TimeToFriendlyStr(now);
     signin_status_.token_info_map[token_name].time = time_as_str;
+    signin_status_.token_info_map[token_name].time_internal = time_as_int;
     profile_->GetPrefs()->SetString(time_pref.c_str(), time_as_str);
+    profile_->GetPrefs()->SetInt64(time_internal_pref.c_str(), time_as_int);
   }
 
   NotifyObservers();
 }
 
 
 void AboutSigninInternals::NotifyTokenReceivedFailure(
     const std::string& token_name,
     const std::string& error) {
-  const std::string time_as_str =
-      UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime(
-          base::Time::NowFromSystemTime()));
+  base::Time now = base::Time::NowFromSystemTime();
+  int64 time_as_int = now.ToInternalValue();
+  const std::string time_as_str = TimeToFriendlyStr(now);
 
   // This should have been initialized already.
   DCHECK(signin_status_.token_info_map.count(token_name));
 
   signin_status_.token_info_map[token_name].token.clear();
   signin_status_.token_info_map[token_name].status = error;
   signin_status_.token_info_map[token_name].time = time_as_str;
+  signin_status_.token_info_map[token_name].time_internal = time_as_int;
 
   // Also update preferences.
   const std::string value_pref = TokenPrefPath(token_name) + ".value";
   const std::string time_pref = TokenPrefPath(token_name) + ".time";
+  const std::string time_internal_pref =
+      TokenPrefPath(token_name) + ".time_internal";
   const std::string status_pref = TokenPrefPath(token_name) + ".status";
   profile_->GetPrefs()->SetString(value_pref.c_str(), std::string());
   profile_->GetPrefs()->SetString(time_pref.c_str(), time_as_str);
+    profile_->GetPrefs()->SetInt64(time_internal_pref.c_str(), time_as_int);
   profile_->GetPrefs()->SetString(status_pref.c_str(), error);
 
   NotifyObservers();
 }
 
 // While clearing tokens, we don't update the time or status.
 void AboutSigninInternals::NotifyClearStoredToken(
     const std::string& token_name) {
   // This should have been initialized already.
   DCHECK(signin_status_.token_info_map.count(token_name));
@@ skipping 27 matching lines @@
 
 void AboutSigninInternals::NotifyObservers() {
   FOR_EACH_OBSERVER(AboutSigninInternals::Observer,
                     signin_observers_,
                     OnSigninStateChanged(signin_status_.ToValue()));
 }
 
 scoped_ptr<DictionaryValue> AboutSigninInternals::GetSigninStatus() {
   return signin_status_.ToValue().Pass();
 }
+
+base::Time AboutSigninInternals::GetTokenTime(
+    const std::string& token_name) const {
+  TokenInfoMap::const_iterator iter =
+      signin_status_.token_info_map.find(token_name);
+  if (iter == signin_status_.token_info_map.end())
+    return base::Time();
+  return base::Time::FromInternalValue(iter->second.time_internal);
+}