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

chrome/browser/task_manager/task_manager.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/task_manager/task_manager.h"
 
 #include "base/bind.h"
 #include "base/i18n/number_formatting.h"
 #include "base/i18n/rtl.h"
 #include "base/location.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/process/process_metrics.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
+#include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/private_working_set_snapshot.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profile_window.h"
 #include "chrome/browser/task_manager/background_information.h"
 #include "chrome/browser/task_manager/browser_process_resource_provider.h"
 #include "chrome/browser/task_manager/child_process_resource_provider.h"
 #include "chrome/browser/task_manager/extension_information.h"
 #include "chrome/browser/task_manager/guest_information.h"
 #include "chrome/browser/task_manager/panel_information.h"
@@ skipping 270 matching lines @@
 
 int TaskManagerModel::GetNaClDebugStubPort(int index) const {
   base::ProcessHandle handle = GetResource(index)->GetProcess();
   PerProcessValues& values(per_process_cache_[handle]);
   if (!values.is_nacl_debug_stub_port_valid) {
     return nacl::kGdbDebugStubPortUnknown;
   }
   return values.nacl_debug_stub_port;
 }
 
-int64 TaskManagerModel::GetNetworkUsage(int index) const {
+int64_t TaskManagerModel::GetNetworkUsage(int index) const {
   return GetNetworkUsage(GetResource(index));
 }
 
 double TaskManagerModel::GetCPUUsage(int index) const {
   return GetCPUUsage(GetResource(index));
 }
 
 int TaskManagerModel::GetIdleWakeupsPerSecond(int index) const {
   return GetIdleWakeupsPerSecond(GetResource(index));
 }
@@ skipping 103 matching lines @@
   if (port == nacl::kGdbDebugStubPortUnknown) {
     return base::ASCIIToUTF16("Unknown");
   } else if (port == nacl::kGdbDebugStubPortUnused) {
     return base::ASCIIToUTF16("N/A");
   } else {
     return base::IntToString16(port);
   }
 }
 
 base::string16 TaskManagerModel::GetResourceNetworkUsage(int index) const {
-  int64 net_usage = GetNetworkUsage(index);
+  int64_t net_usage = GetNetworkUsage(index);
   if (net_usage == -1)
     return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT);
   if (net_usage == 0)
     return base::ASCIIToUTF16("0");
   base::string16 net_byte = ui::FormatSpeed(net_usage);
   // Force number string to have LTR directionality.
   return base::i18n::GetDisplayStringInLTRDirectionality(net_byte);
 }
 
 base::string16 TaskManagerModel::GetResourceCPUUsage(int index) const {
@@ skipping 878 matching lines @@
     return;
 
   if (!video_memory_usage_stats_observer_.get()) {
     video_memory_usage_stats_observer_.reset(
         new TaskManagerModelGpuDataManagerObserver());
   }
   pending_video_memory_usage_stats_update_ = true;
   content::GpuDataManager::GetInstance()->RequestVideoMemoryUsageStatsUpdate();
 }
 
-int64 TaskManagerModel::GetNetworkUsageForResource(Resource* resource) const {
+int64_t TaskManagerModel::GetNetworkUsageForResource(Resource* resource) const {
   // Returns default of 0 if no network usage.
   return per_resource_cache_[resource].network_usage;
 }
 
 void TaskManagerModel::BytesRead(BytesReadParam param) {
   if (update_state_ != TASK_PENDING || listen_requests_ == 0) {
     // A notification sneaked in while we were stopping the updating, just
     // ignore it.
     return;
   }
@@ skipping 55 matching lines @@
       BrowserThread::UI, FROM_HERE,
       base::Bind(&TaskManagerModel::MultipleBytesRead, this,
                  base::Owned(bytes_read_buffer)));
 }
 
 void TaskManagerModel::SetUpdatingByteCount(bool is_updating) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   is_updating_byte_count_ = is_updating;
 }
 
-int64 TaskManagerModel::GetNetworkUsage(Resource* resource) const {
-  int64 net_usage = GetNetworkUsageForResource(resource);
+int64_t TaskManagerModel::GetNetworkUsage(Resource* resource) const {
+  int64_t net_usage = GetNetworkUsageForResource(resource);
   if (net_usage == 0 && !resource->SupportNetworkUsage())
     return -1;
   return net_usage;
 }
 
 double TaskManagerModel::GetCPUUsage(Resource* resource) const {
   const PerProcessValues& values(per_process_cache_[resource->GetProcess()]);
   // Returns 0 if not valid, which is fine.
   return values.cpu_usage;
 }
 
 int TaskManagerModel::GetIdleWakeupsPerSecond(Resource* resource) const {
   const PerProcessValues& values(per_process_cache_[resource->GetProcess()]);
   // Returns 0 if not valid, which is fine.
   return values.idle_wakeups;
 }
 
-base::string16 TaskManagerModel::GetMemCellText(int64 number) const {
+base::string16 TaskManagerModel::GetMemCellText(int64_t number) const {
 #if !defined(OS_MACOSX)
   base::string16 str = base::FormatNumber(number / 1024);
 
   // Adjust number string if necessary.
   base::i18n::AdjustStringForLocaleDirection(&str);
   return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_MEM_CELL_TEXT, str);
 #else
   // System expectation is to show "100 kB", "200 MB", etc.
   // TODO(thakis): Switch to metric units (as opposed to powers of two).
   return ui::FormatBytes(number);
@@ skipping 129 matching lines @@
   params.host_desktop_type = desktop_type;
   chrome::Navigate(&params);
 }
 
 TaskManager::TaskManager()
     : model_(new TaskManagerModel(this)) {
 }
 
 TaskManager::~TaskManager() {
 }