chrome/browser/process_resource_usage.cc

   1 // Copyright 2015 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/process_resource_usage.h"
   6
   7 #include <utility>
   8
   9 #include "base/check.h"
  10 #include "base/functional/bind.h"
  11 #include "base/location.h"
  12 #include "base/task/single_thread_task_runner.h"
  13 #include "content/public/common/resource_usage_reporter_type_converters.h"
  14
  15 ProcessResourceUsage::ProcessResourceUsage(
  16     mojo::PendingRemote<content::mojom::ResourceUsageReporter> service)
  17     : service_(std::move(service)), update_in_progress_(false) {
  18   service_.set_disconnect_handler(
  19       base::BindOnce(&ProcessResourceUsage::RunPendingRefreshCallbacks,
  20                      base::Unretained(this)));
  21 }
  22
  23 ProcessResourceUsage::~ProcessResourceUsage() {
  24   DCHECK(thread_checker_.CalledOnValidThread());
  25 }
  26
  27 void ProcessResourceUsage::RunPendingRefreshCallbacks() {
  28   DCHECK(thread_checker_.CalledOnValidThread());
  29   auto task_runner = base::SingleThreadTaskRunner::GetCurrentDefault();
  30   base::circular_deque<base::OnceClosure> callbacks;
  31   std::swap(callbacks, refresh_callbacks_);
  32   for (auto& callback : callbacks)
  33     task_runner->PostTask(FROM_HERE, std::move(callback));
  34 }
  35
  36 void ProcessResourceUsage::Refresh(base::OnceClosure callback) {
  37   DCHECK(thread_checker_.CalledOnValidThread());
  38   if (!service_ || !service_.is_connected()) {
  39     if (!callback.is_null())
  40       base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
  41           FROM_HERE, std::move(callback));
  42     return;
  43   }
  44
  45   if (!callback.is_null())
  46     refresh_callbacks_.push_back(std::move(callback));
  47
  48   if (!update_in_progress_) {
  49     update_in_progress_ = true;
  50     service_->GetUsageData(base::BindOnce(&ProcessResourceUsage::OnRefreshDone,
  51                                           base::Unretained(this)));
  52   }
  53 }
  54
  55 void ProcessResourceUsage::OnRefreshDone(
  56     content::mojom::ResourceUsageDataPtr data) {
  57   DCHECK(thread_checker_.CalledOnValidThread());
  58   update_in_progress_ = false;
  59   stats_ = std::move(data);
  60   RunPendingRefreshCallbacks();
  61 }
  62
  63 bool ProcessResourceUsage::ReportsV8MemoryStats() const {
  64   DCHECK(thread_checker_.CalledOnValidThread());
  65   if (stats_)
  66     return stats_->reports_v8_stats;
  67   return false;
  68 }
  69
  70 size_t ProcessResourceUsage::GetV8MemoryAllocated() const {
  71   DCHECK(thread_checker_.CalledOnValidThread());
  72   if (stats_ && stats_->reports_v8_stats)
  73     return stats_->v8_bytes_allocated;
  74   return 0;
  75 }
  76
  77 size_t ProcessResourceUsage::GetV8MemoryUsed() const {
  78   DCHECK(thread_checker_.CalledOnValidThread());
  79   if (stats_ && stats_->reports_v8_stats)
  80     return stats_->v8_bytes_used;
  81   return 0;
  82 }
  83
  84 blink::WebCacheResourceTypeStats
  85 ProcessResourceUsage::GetBlinkMemoryCacheStats() const {
  86   DCHECK(thread_checker_.CalledOnValidThread());
  87   if (stats_ && stats_->web_cache_stats)
  88     return stats_->web_cache_stats->To<blink::WebCacheResourceTypeStats>();
  89   return {};
  90 }