Switch to standard integer types in content/browser/.

content/browser/gpu/gpu_data_manager_impl_private.cc

 // Copyright (c) 2013 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 "content/browser/gpu/gpu_data_manager_impl_private.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/trace_event/trace_event.h"
 #include "base/version.h"
+#include "build/build_config.h"
 #include "cc/base/switches.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/gpu_data_manager_observer.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/web_preferences.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
@@ skipping 76 matching lines @@
       break;
   }
   return entry_index;
 }
 #endif  // OS_WIN
 
 // Send UMA histograms about the enabled features and GPU properties.
 void UpdateStats(const gpu::GPUInfo& gpu_info,
                  const gpu::GpuBlacklist* blacklist,
                  const std::set<int>& blacklisted_features) {
-  uint32 max_entry_id = blacklist->max_entry_id();
+  uint32_t max_entry_id = blacklist->max_entry_id();
   if (max_entry_id == 0) {
     // GPU Blacklist was not loaded.  No need to go further.
     return;
   }
 
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   bool disabled = false;
 
   // Use entry 0 to capture the total number of times that data
   // was recorded in this histogram in order to have a convenient
   // denominator to compute blacklist percentages for the rest of the
   // entries.
   UMA_HISTOGRAM_ENUMERATION("GPU.BlacklistTestResultsPerEntry",
       0, max_entry_id + 1);
 
   if (blacklisted_features.size() != 0) {
-    std::vector<uint32> flag_entries;
+    std::vector<uint32_t> flag_entries;
     blacklist->GetDecisionEntries(&flag_entries, disabled);
     DCHECK_GT(flag_entries.size(), 0u);
     for (size_t i = 0; i < flag_entries.size(); ++i) {
       UMA_HISTOGRAM_ENUMERATION("GPU.BlacklistTestResultsPerEntry",
           flag_entries[i], max_entry_id + 1);
     }
   }
 
   // This counts how many users are affected by a disabled entry - this allows
   // us to understand the impact of an entry before enable it.
-  std::vector<uint32> flag_disabled_entries;
+  std::vector<uint32_t> flag_disabled_entries;
   disabled = true;
   blacklist->GetDecisionEntries(&flag_disabled_entries, disabled);
-  for (uint32 disabled_entry : flag_disabled_entries) {
+  for (uint32_t disabled_entry : flag_disabled_entries) {
     UMA_HISTOGRAM_ENUMERATION("GPU.BlacklistTestResultsPerDisabledEntry",
         disabled_entry, max_entry_id + 1);
   }
 
   const gpu::GpuFeatureType kGpuFeatures[] = {
       gpu::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS,
       gpu::GPU_FEATURE_TYPE_GPU_COMPOSITING,
       gpu::GPU_FEATURE_TYPE_GPU_RASTERIZATION,
       gpu::GPU_FEATURE_TYPE_WEBGL};
   const std::string kGpuBlacklistFeatureHistogramNames[] = {
@@ skipping 70 matching lines @@
   uint32_t displayCount;
   CGGetActiveDisplayList(0, NULL, &displayCount);
   if (displayCount != manager->GetDisplayCount()) {
     manager->SetDisplayCount(displayCount);
     display_changed = true;
   }
 
   // Gpu change.
   bool gpu_changed = false;
   if (flags & kCGDisplayAddFlag) {
-    uint32 vendor_id, device_id;
+    uint32_t vendor_id, device_id;
     if (gpu::CollectGpuID(&vendor_id, &device_id) == gpu::kCollectInfoSuccess) {
       gpu_changed = manager->UpdateActiveGpu(vendor_id, device_id);
     }
   }
 
   if (display_changed || gpu_changed)
     manager->HandleGpuSwitch();
 }
 #endif  // OS_MACOSX
 
 // Block all domains' use of 3D APIs for this many milliseconds if
 // approaching a threshold where system stability might be compromised.
-const int64 kBlockAllDomainsMs = 10000;
+const int64_t kBlockAllDomainsMs = 10000;
 const int kNumResetsWithinDuration = 1;
 
 // Enums for UMA histograms.
 enum BlockStatusHistogram {
   BLOCK_STATUS_NOT_BLOCKED,
   BLOCK_STATUS_SPECIFIC_DOMAIN_BLOCKED,
   BLOCK_STATUS_ALL_DOMAINS_BLOCKED,
   BLOCK_STATUS_MAX
 };
 
@@ skipping 606 matching lines @@
   GpuDataManagerImpl::UnlockedSession session(owner_);
   // Notify observers in the browser process.
   ui::GpuSwitchingManager::GetInstance()->NotifyGpuSwitched();
   // Pass the notification to the GPU process to notify observers there.
   GpuProcessHost::SendOnIO(
       GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
       CAUSE_FOR_GPU_LAUNCH_NO_LAUNCH,
       new GpuMsg_GpuSwitched);
 }
 
-bool GpuDataManagerImplPrivate::UpdateActiveGpu(
-    uint32 vendor_id, uint32 device_id) {
+bool GpuDataManagerImplPrivate::UpdateActiveGpu(uint32_t vendor_id,
+                                                uint32_t device_id) {
   if (gpu_info_.gpu.vendor_id == vendor_id &&
       gpu_info_.gpu.device_id == device_id) {
     // The primary GPU is active.
     if (gpu_info_.gpu.active)
       return false;
     gpu_info_.gpu.active = true;
     for (size_t ii = 0; ii < gpu_info_.secondary_gpus.size(); ++ii)
       gpu_info_.secondary_gpus[ii].active = false;
   } else {
     // A secondary GPU is active.
@@ skipping 170 matching lines @@
 }
 
 void GpuDataManagerImplPrivate::UpdatePreliminaryBlacklistedFeatures() {
   preliminary_blacklisted_features_ = blacklisted_features_;
 }
 
 void GpuDataManagerImplPrivate::UpdateGpuSwitchingManager(
     const gpu::GPUInfo& gpu_info) {
   // The vendor IDs might be 0 on non-PCI devices (like Android), but
   // the length of the vector is all we care about in most cases.
-  std::vector<uint32> vendor_ids;
+  std::vector<uint32_t> vendor_ids;
   vendor_ids.push_back(gpu_info.gpu.vendor_id);
   for (const auto& device : gpu_info.secondary_gpus) {
     vendor_ids.push_back(device.vendor_id);
   }
   ui::GpuSwitchingManager::GetInstance()->SetGpuVendorIds(vendor_ids);
 
   if (ui::GpuSwitchingManager::GetInstance()->SupportsDualGpus()) {
     if (gpu_driver_bugs_.count(gpu::FORCE_DISCRETE_GPU) == 1)
       ui::GpuSwitchingManager::GetInstance()->ForceUseOfDiscreteGpu();
     else if (gpu_driver_bugs_.count(gpu::FORCE_INTEGRATED_GPU) == 1)
@@ skipping 119 matching lines @@
     }
   }
 
   UMA_HISTOGRAM_ENUMERATION("GPU.BlockStatusForClient3DAPIs",
                             BLOCK_STATUS_NOT_BLOCKED,
                             BLOCK_STATUS_MAX);
 
   return GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_NOT_BLOCKED;
 }
 
-int64 GpuDataManagerImplPrivate::GetBlockAllDomainsDurationInMs() const {
+int64_t GpuDataManagerImplPrivate::GetBlockAllDomainsDurationInMs() const {
   return kBlockAllDomainsMs;
 }
 
 void GpuDataManagerImplPrivate::Notify3DAPIBlocked(const GURL& top_origin_url,
                                                    int render_process_id,
                                                    int render_frame_id,
                                                    ThreeDAPIType requester) {
   GpuDataManagerImpl::UnlockedSession session(owner_);
   observer_list_->Notify(FROM_HERE, &GpuDataManagerObserver::DidBlock3DAPIs,
                          top_origin_url, render_process_id, render_frame_id,
                          requester);
 }
 
 void GpuDataManagerImplPrivate::OnGpuProcessInitFailure() {
   gpu_process_accessible_ = false;
   gpu_info_.context_info_state = gpu::kCollectInfoFatalFailure;
 #if defined(OS_WIN)
   gpu_info_.dx_diagnostics_info_state = gpu::kCollectInfoFatalFailure;
 #endif
   complete_gpu_info_already_requested_ = true;
   // Some observers might be waiting.
   NotifyGpuInfoUpdate();
 }
 
 }  // namespace content