Switch to standard integer types in chrome/browser/, part 3 of 4.

chrome/browser/password_manager/native_backend_libsecret.cc

 // Copyright (c) 2015 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/password_manager/native_backend_libsecret.h"
 
 #include <dlfcn.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <list>
 
-#include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/password_manager/core/browser/password_manager_metrics_util.h"
 #include "components/password_manager/core/browser/password_manager_util.h"
 
 using autofill::PasswordForm;
@@ skipping 132 matching lines @@
       UTF8ToUTF16(GetStringFromAttributes(attrs, "username_element"));
   form->username_value =
       UTF8ToUTF16(GetStringFromAttributes(attrs, "username_value"));
   form->password_element =
       UTF8ToUTF16(GetStringFromAttributes(attrs, "password_element"));
   form->submit_element =
       UTF8ToUTF16(GetStringFromAttributes(attrs, "submit_element"));
   form->signon_realm = GetStringFromAttributes(attrs, "signon_realm");
   form->ssl_valid = GetUintFromAttributes(attrs, "ssl_valid");
   form->preferred = GetUintFromAttributes(attrs, "preferred");
-  int64 date_created = 0;
+  int64_t date_created = 0;
   bool date_ok = base::StringToInt64(
       GetStringFromAttributes(attrs, "date_created"), &date_created);
   DCHECK(date_ok);
   // In the past |date_created| was stored as time_t. Currently is stored as
   // base::Time's internal value. We need to distinguish, which format the
   // number in |date_created| was stored in. We use the fact that
   // kMaxPossibleTimeTValue interpreted as the internal value corresponds to an
   // unlikely date back in 17th century, and anything above
   // kMaxPossibleTimeTValue clearly must be in the internal value format.
   form->date_created = date_created < kMaxPossibleTimeTValue
                            ? base::Time::FromTimeT(date_created)
                            : base::Time::FromInternalValue(date_created);
   form->blacklisted_by_user =
       GetUintFromAttributes(attrs, "blacklisted_by_user");
   form->type =
       static_cast<PasswordForm::Type>(GetUintFromAttributes(attrs, "type"));
   form->times_used = GetUintFromAttributes(attrs, "times_used");
   form->scheme =
       static_cast<PasswordForm::Scheme>(GetUintFromAttributes(attrs, "scheme"));
-  int64 date_synced = 0;
+  int64_t date_synced = 0;
   base::StringToInt64(GetStringFromAttributes(attrs, "date_synced"),
                       &date_synced);
   form->date_synced = base::Time::FromInternalValue(date_synced);
   form->display_name =
       UTF8ToUTF16(GetStringFromAttributes(attrs, "display_name"));
   form->icon_url = GURL(GetStringFromAttributes(attrs, "avatar_url"));
   form->federation_url = GURL(GetStringFromAttributes(attrs, "federation_url"));
   form->skip_zero_click = GetUintFromAttributes(attrs, "skip_zero_click");
   form->generation_upload_status =
       static_cast<PasswordForm::GenerationUploadStatus>(
           GetUintFromAttributes(attrs, "generation_upload_status"));
   base::StringPiece encoded_form_data =
       GetStringFromAttributes(attrs, "form_data");
   if (!encoded_form_data.empty()) {
     bool success = DeserializeFormDataFromBase64String(encoded_form_data,
                                                        &form->form_data);
     password_manager::metrics_util::FormDeserializationStatus status =
         success ? password_manager::metrics_util::GNOME_SUCCESS
                 : password_manager::metrics_util::GNOME_FAILURE;
     LogFormDataDeserializationStatus(status);
   }
   return form.Pass();
 }
 
 class LibsecretAttributesBuilder {
  public:
   LibsecretAttributesBuilder();
   ~LibsecretAttributesBuilder();
   void Append(const std::string& name, const std::string& value);
-  void Append(const std::string& name, int64 value);
+  void Append(const std::string& name, int64_t value);
   // GHashTable, its keys and values returned from Get() are destroyed in
   // |LibsecretAttributesBuilder| desctructor.
   GHashTable* Get() { return attrs_; }
 
  private:
   // |name_values_| is a storage for strings referenced in |attrs_|.
   std::list<std::string> name_values_;
   GHashTable* attrs_;
 };
 
@@ skipping 11 matching lines @@
                                         const std::string& value) {
   name_values_.push_back(name);
   gpointer name_str =
       static_cast<gpointer>(const_cast<char*>(name_values_.back().c_str()));
   name_values_.push_back(value);
   gpointer value_str =
       static_cast<gpointer>(const_cast<char*>(name_values_.back().c_str()));
   g_hash_table_insert(attrs_, name_str, value_str);
 }
 
-void LibsecretAttributesBuilder::Append(const std::string& name, int64 value) {
+void LibsecretAttributesBuilder::Append(const std::string& name,
+                                        int64_t value) {
   Append(name, base::Int64ToString(value));
 }
 
 // Generates a profile-specific app string based on profile_id_.
 std::string GetProfileSpecificAppString(LocalProfileId id) {
   // Originally, the application string was always just "chrome" and used only
   // so that we had *something* to search for since GNOME Keyring won't search
   // for nothing. Now we use it to distinguish passwords for different profiles.
   return base::StringPrintf("%s-%d", kLibsecretAppString, id);
 }
@@ skipping 170 matching lines @@
     if (found)
       g_list_free(found);
     return false;
   }
 
   *forms = ConvertFormList(found, &lookup_form);
   return true;
 }
 
 bool NativeBackendLibsecret::RawAddLogin(const PasswordForm& form) {
-  int64 date_created = form.date_created.ToInternalValue();
+  int64_t date_created = form.date_created.ToInternalValue();
   // If we are asked to save a password with 0 date, use the current time.
   // We don't want to actually save passwords as though on January 1, 1601.
   if (!date_created)
     date_created = base::Time::Now().ToInternalValue();
-  int64 date_synced = form.date_synced.ToInternalValue();
+  int64_t date_synced = form.date_synced.ToInternalValue();
   std::string form_data;
   SerializeFormDataToBase64String(form.form_data, &form_data);
   GError* error = nullptr;
   secret_password_store_sync(
       &kLibsecretSchema,
       nullptr,                     // Default collection.
       form.origin.spec().c_str(),  // Display name.
       UTF16ToUTF8(form.password_value).c_str(),
       nullptr,  // no cancellable ojbect
       &error,
@@ skipping 184 matching lines @@
     UMA_HISTOGRAM_ENUMERATION(
         "PasswordManager.PslDomainMatchTriggering",
         password_manager::ShouldPSLDomainMatchingApply(registered_domain)
             ? psl_domain_match_metric
             : password_manager::PSL_DOMAIN_MATCH_NOT_USED,
         password_manager::PSL_DOMAIN_MATCH_COUNT);
   }
   g_list_free(found);
   return forms.Pass();
 }