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

chrome/browser/metrics/perf/perf_provider_chromeos.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/metrics/perf/perf_provider_chromeos.h"
 
+#include <stddef.h>
+
 #include <algorithm>
 #include <map>
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
@@ skipping 55 matching lines @@
 // Returns a random TimeDelta between zero and |max|.
 base::TimeDelta RandomTimeDelta(base::TimeDelta max) {
   return base::TimeDelta::FromMicroseconds(
       base::RandGenerator(max.InMicroseconds()));
 }
 
 // Gets parameter named by |key| from the map. If it is present and is an
 // integer, stores the result in |out| and return true. Otherwise return false.
 bool GetInt64Param(const std::map<std::string, std::string>& params,
                    const std::string& key,
-                   int64* out) {
+                   int64_t* out) {
   auto it = params.find(key);
   if (it == params.end())
     return false;
-  int64 value;
+  int64_t value;
   // NB: StringToInt64 will set value even if the conversion fails.
   if (!base::StringToInt64(it->second, &value))
     return false;
   *out = value;
   return true;
 }
 
 // Parses the key. e.g.: "PerfCommand::arm::0" returns "arm"
 bool ExtractPerfCommandCpuSpecifier(const std::string& key,
                                     std::string* cpu_specifier) {
@@ skipping 96 matching lines @@
     base::TimeDelta periodic_interval,
     TriggerParams resume_from_suspend,
     TriggerParams restore_session)
     : collection_duration_(collection_duration.ToInternalValue()),
       periodic_interval_(periodic_interval.ToInternalValue()),
       resume_from_suspend_(resume_from_suspend),
       restore_session_(restore_session) {
 }
 
 PerfProvider::CollectionParams::TriggerParams::TriggerParams(
-    int64 sampling_factor,
+    int64_t sampling_factor,
     base::TimeDelta max_collection_delay)
     : sampling_factor_(sampling_factor),
-      max_collection_delay_(max_collection_delay.ToInternalValue()) {
-}
+      max_collection_delay_(max_collection_delay.ToInternalValue()) {}
 
 const PerfProvider::CollectionParams PerfProvider::kDefaultParameters(
   /* collection_duration = */ base::TimeDelta::FromSeconds(2),
   /* periodic_interval = */ base::TimeDelta::FromHours(3),
   /* resume_from_suspend = */ PerfProvider::CollectionParams::TriggerParams(
       /* sampling_factor = */ 10,
       /* max_collection_delay = */ base::TimeDelta::FromSeconds(5)),
   /* restore_session = */ PerfProvider::CollectionParams::TriggerParams(
       /* sampling_factor = */ 10,
       /* max_collection_delay = */ base::TimeDelta::FromSeconds(10)));
@@ skipping 82 matching lines @@
       ret = cpu_specifier;
     }
   }
   return ret;
 }
 
 }  // namespace internal
 
 void PerfProvider::SetCollectionParamsFromVariationParams(
     const std::map<std::string, std::string>& params) {
-  int64 value;
+  int64_t value;
   if (GetInt64Param(params, "ProfileCollectionDurationSec", &value)) {
     collection_params_.set_collection_duration(
         base::TimeDelta::FromSeconds(value));
   }
   if (GetInt64Param(params, "PeriodicProfilingIntervalMs", &value)) {
     collection_params_.set_periodic_interval(
         base::TimeDelta::FromMilliseconds(value));
   }
   if (GetInt64Param(params, "ResumeFromSuspend::SamplingFactor", &value)) {
     collection_params_.mutable_resume_from_suspend()
@@ skipping 54 matching lines @@
   cached_perf_data_.clear();
 
   AddToPerfHistogram(SUCCESS);
   return true;
 }
 
 void PerfProvider::ParseOutputProtoIfValid(
     scoped_ptr<WindowedIncognitoObserver> incognito_observer,
     scoped_ptr<SampledProfile> sampled_profile,
     int result,
-    const std::vector<uint8>& perf_data,
-    const std::vector<uint8>& perf_stat) {
+    const std::vector<uint8_t>& perf_data,
+    const std::vector<uint8_t>& perf_stat) {
   DCHECK(CalledOnValidThread());
 
   if (incognito_observer->incognito_launched()) {
     AddToPerfHistogram(INCOGNITO_LAUNCHED);
     return;
   }
 
   if (result != 0 || (perf_data.empty() && perf_stat.empty())) {
     AddToPerfHistogram(PROTOBUF_NOT_PARSED);
     return;
@@ skipping 216 matching lines @@
   scoped_ptr<SampledProfile> sampled_profile(new SampledProfile);
   sampled_profile->set_trigger_event(SampledProfile::RESTORE_SESSION);
   sampled_profile->set_ms_after_restore(time_after_restore.InMilliseconds());
   sampled_profile->set_num_tabs_restored(num_tabs_restored);
 
   CollectIfNecessary(sampled_profile.Pass());
   last_session_restore_collection_time_ = base::TimeTicks::Now();
 }
 
 }  // namespace metrics