Avoid loading an empty token when decrypt failed

components/signin/core/browser/webdata/token_service_table.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/signin/core/browser/webdata/token_service_table.h"
 
 #include <map>
 #include <string>
 
 #include "base/logging.h"
+#include "base/metrics/histogram_macros.h"
 #include "components/os_crypt/os_crypt.h"
 #include "components/webdata/common/web_database.h"
 #include "sql/statement.h"
 
 namespace {
 
 WebDatabaseTable::TypeKey GetKey() {
   // We just need a unique constant. Use the address of a static that
   // COMDAT folding won't touch in an optimizing linker.
   static int table_key = 0;
   return reinterpret_cast<void*>(&table_key);
 }
 
+// Entries in the |Signin.TokenTable.ReadTokenFromDBResult| histogram.
+enum ReadOneTokenResult {
+  READ_ONE_TOKEN_SUCCESS,
+  READ_ONE_TOKEN_DB_SUCCESS_DECRYPT_FAILED,
+  READ_ONE_TOKEN_DB_FAILED_BAD_ENTRY,
+  READ_ONE_TOKEN_MAX_VALUE
+};
+
 }  // namespace
 
 TokenServiceTable* TokenServiceTable::FromWebDatabase(WebDatabase* db) {
   return static_cast<TokenServiceTable*>(db->GetTable(GetKey()));
 
 }
 
 WebDatabaseTable::TypeKey TokenServiceTable::GetTypeKey() const {
   return GetKey();
 }
@@ skipping 52 matching lines @@
              static_cast<int>(encrypted_token.length()));
 
   return s.Run();
 }
 
 bool TokenServiceTable::GetAllTokens(
     std::map<std::string, std::string>* tokens) {
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT service, encrypted_token FROM token_service"));
 
-  if (!s.is_valid())
+  UMA_HISTOGRAM_BOOLEAN("Signin.TokenTable.GetAllTokensSqlStatementValidity",
+                        s.is_valid());
+
+  if (!s.is_valid()) {
+    LOG(ERROR) << "Failed to load tokens (invalid SQL statement).";
     return false;
+  }
 
+  bool read_all_tokens_result = true;
   while (s.Step()) {
+    ReadOneTokenResult read_token_result = READ_ONE_TOKEN_MAX_VALUE;
+
     std::string encrypted_token;
     std::string decrypted_token;
     std::string service;
     service = s.ColumnString(0);
     bool entry_ok = !service.empty() &&
                     s.ColumnBlobAsString(1, &encrypted_token);
     if (entry_ok) {
-      OSCrypt::DecryptString(encrypted_token, &decrypted_token);
-      (*tokens)[service] = decrypted_token;
+      if (OSCrypt::DecryptString(encrypted_token, &decrypted_token)) {
+        (*tokens)[service] = decrypted_token;
+        read_token_result = READ_ONE_TOKEN_SUCCESS;
+      } else {
+        // Chrome relies on native APIs to encrypt and decrypt the tokens which
+        // may fail (see http://crbug.com/686485).
+        LOG(ERROR) << "Failed to decrypt token for service " << service;
+        read_token_result = READ_ONE_TOKEN_DB_SUCCESS_DECRYPT_FAILED;
+        read_all_tokens_result = false;
+      }
     } else {
-      NOTREACHED();
-      return false;
+      LOG(ERROR) << "Bad token entry for service " << service;
+      read_token_result = READ_ONE_TOKEN_DB_FAILED_BAD_ENTRY;
+      read_all_tokens_result = false;
     }
+    DCHECK_LT(read_token_result, READ_ONE_TOKEN_MAX_VALUE);
+    UMA_HISTOGRAM_ENUMERATION("Signin.TokenTable.ReadTokenFromDBResult",
+                              read_token_result,
+                              READ_ONE_TOKEN_MAX_VALUE);
   }
-  return true;
+  return read_all_tokens_result;
 }