content/browser/power_usage_monitor_impl.cc - chromium/src.git - Git at Google

 // Copyright 2014 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/power_usage_monitor_impl.h"

 #include <stddef.h>
 #include <utility>

 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/power_usage_monitor.h"
 #include "content/public/browser/render_process_host.h"

 namespace content {

 namespace {

 // Wait this long after power on before enabling power usage monitoring.
 const int kMinUptimeMinutes = 30;

 // Minimum discharge time after which we collect the discharge rate.
 const int kMinDischargeMinutes = 30;

 class PowerUsageMonitorSystemInterface
     : public PowerUsageMonitor::SystemInterface {
  public:
   explicit PowerUsageMonitorSystemInterface(PowerUsageMonitor* owner)
       : power_usage_monitor_(owner),
         weak_ptr_factory_(this) {}
   ~PowerUsageMonitorSystemInterface() override {}

   void ScheduleHistogramReport(base::TimeDelta delay) override {
     BrowserThread::PostDelayedTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(
             &PowerUsageMonitorSystemInterface::ReportBatteryLevelHistogram,
             weak_ptr_factory_.GetWeakPtr(),
             Now(),
             delay),
         delay);
   }

   void CancelPendingHistogramReports() override {
     weak_ptr_factory_.InvalidateWeakPtrs();
   }

   void RecordDischargePercentPerHour(int percent_per_hour) override {
     UMA_HISTOGRAM_PERCENTAGE("Power.BatteryDischargePercentPerHour",
                              percent_per_hour);
   }

   base::Time Now() override { return base::Time::Now(); }

  protected:
   void ReportBatteryLevelHistogram(base::Time start_time,
                                    base::TimeDelta discharge_time) {
     // It's conceivable that the code to cancel pending histogram reports on
     // system suspend, will only get called after the system has woken up.
     // To mitigage this, check whether more time has passed than expected and
     // abort histogram recording in this case.

     // Delayed tasks are subject to timer coalescing and can fire anywhere from
     // delay -> delay * 1.5) . In most cases, the OS should fire the task
     // at the next wakeup and not as late as it can.
     // A threshold of 2 minutes is used, since that should be large enough to
     // take the slop factor due to coalescing into account.
     base::TimeDelta threshold = discharge_time +
         base::TimeDelta::FromMinutes(2);
     if ((Now() - start_time) > threshold) {
       return;
     }

     const std::string histogram_name = base::StringPrintf(
         "Power.BatteryDischarge_%d", discharge_time.InMinutes());
     base::HistogramBase* histogram =
         base::Histogram::FactoryGet(histogram_name,
                                     1,
                                     100,
                                     101,
                                     base::Histogram::kUmaTargetedHistogramFlag);
     double discharge_amount = power_usage_monitor_->discharge_amount();
     histogram->Add(discharge_amount * 100);
   }

  private:
   PowerUsageMonitor* power_usage_monitor_;  // Not owned.

   // Used to cancel in progress delayed tasks.
   base::WeakPtrFactory<PowerUsageMonitorSystemInterface> weak_ptr_factory_;
 };

 }  // namespace

 void StartPowerUsageMonitor() {
   static base::LazyInstance<PowerUsageMonitor>::Leaky monitor =
      LAZY_INSTANCE_INITIALIZER;
   monitor.Get().Start();
 }

 PowerUsageMonitor::PowerUsageMonitor()
     : callback_(base::Bind(&PowerUsageMonitor::OnBatteryStatusUpdate,
           base::Unretained(this))),
       system_interface_(new PowerUsageMonitorSystemInterface(this)),
       started_(false),
       tracking_discharge_(false),
       on_battery_power_(false),
       initial_battery_level_(0),
       current_battery_level_(0) {
 }

 PowerUsageMonitor::~PowerUsageMonitor() {
   if (started_)
     base::PowerMonitor::Get()->RemoveObserver(this);
 }

 void PowerUsageMonitor::Start() {
   // Power monitoring may be delayed based on uptime, but renderer process
   // lifetime tracking needs to start immediately so processes created before
   // then are accounted for.
   registrar_.Add(this,
                  NOTIFICATION_RENDERER_PROCESS_CREATED,
                  NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this,
                  NOTIFICATION_RENDERER_PROCESS_CLOSED,
                  NotificationService::AllBrowserContextsAndSources());
   subscription_ =
       device::BatteryStatusService::GetInstance()->AddCallback(callback_);

   // Delay initialization until the system has been up for a while.
   // This is to mitigate the effect of increased power draw during system start.
   base::TimeDelta uptime = base::SysInfo::Uptime();
   base::TimeDelta min_uptime = base::TimeDelta::FromMinutes(kMinUptimeMinutes);
   if (uptime < min_uptime) {
     base::TimeDelta delay = min_uptime - uptime;
     BrowserThread::PostDelayedTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&PowerUsageMonitor::StartInternal, base::Unretained(this)),
         delay);
   } else {
     StartInternal();
   }
 }

 void PowerUsageMonitor::StartInternal() {
   DCHECK(!started_);
   started_ = true;

   // PowerMonitor is used to get suspend/resume notifications.
   base::PowerMonitor::Get()->AddObserver(this);
 }

 void PowerUsageMonitor::DischargeStarted(double battery_level) {
   on_battery_power_ = true;

   // If all browser windows are closed, don't report power metrics since
   // Chrome's power draw is likely not significant.
   if (live_renderer_ids_.empty())
     return;

   // Cancel any in-progress ReportBatteryLevelHistogram() calls.
   system_interface_->CancelPendingHistogramReports();

   tracking_discharge_ = true;
   start_discharge_time_ = system_interface_->Now();

   initial_battery_level_ = battery_level;
   current_battery_level_ = battery_level;

   const int kBatteryReportingIntervalMinutes[] = {5, 15, 30};
   for (auto reporting_interval : kBatteryReportingIntervalMinutes) {
     base::TimeDelta delay = base::TimeDelta::FromMinutes(reporting_interval);
     system_interface_->ScheduleHistogramReport(delay);
   }
 }

 void PowerUsageMonitor::WallPowerConnected(double battery_level) {
   on_battery_power_ = false;

   if (tracking_discharge_) {
     DCHECK(!start_discharge_time_.is_null());
     base::TimeDelta discharge_time =
         system_interface_->Now() - start_discharge_time_;

     if (discharge_time.InMinutes() > kMinDischargeMinutes) {
       // Record the rate at which the battery discharged over the entire period
       // the system was on battery power.
       double discharge_hours = discharge_time.InSecondsF() / 3600.0;
       int percent_per_hour =
           floor(((discharge_amount() / discharge_hours) * 100.0) + 0.5);
       system_interface_->RecordDischargePercentPerHour(percent_per_hour);
     }
   }

   // Cancel any in-progress ReportBatteryLevelHistogram() calls.
   system_interface_->CancelPendingHistogramReports();

   initial_battery_level_ = 0;
   current_battery_level_ = 0;
   start_discharge_time_ = base::Time();
   tracking_discharge_ = false;
 }

 void PowerUsageMonitor::OnBatteryStatusUpdate(
     const device::BatteryStatus& status) {
   bool now_on_battery_power = (status.charging == 0);
   bool was_on_battery_power = on_battery_power_;
   double battery_level = status.level;

   if (now_on_battery_power == was_on_battery_power) {
     if (now_on_battery_power)
       current_battery_level_ = battery_level;
     return;
   } else if (now_on_battery_power) {  // Wall power disconnected.
     DischargeStarted(battery_level);
   } else {  // Wall power connected.
     WallPowerConnected(battery_level);
   }
 }

 void PowerUsageMonitor::OnRenderProcessNotification(int type, int rph_id) {
   size_t previous_num_live_renderers = live_renderer_ids_.size();

   if (type == NOTIFICATION_RENDERER_PROCESS_CREATED) {
     live_renderer_ids_.insert(rph_id);
   } else if (type == NOTIFICATION_RENDERER_PROCESS_CLOSED) {
     live_renderer_ids_.erase(rph_id);
   } else {
     NOTREACHED()  << "Unexpected notification type: " << type;
   }

   if (live_renderer_ids_.empty() && previous_num_live_renderers != 0) {
     // All render processes have died.
     CancelPendingHistogramReporting();
     tracking_discharge_ = false;
   }

 }

 void PowerUsageMonitor::SetSystemInterfaceForTest(
     std::unique_ptr<SystemInterface> interface) {
   system_interface_ = std::move(interface);
 }

 void PowerUsageMonitor::OnPowerStateChange(bool on_battery_power) {
 }

 void PowerUsageMonitor::OnResume() {
 }

 void PowerUsageMonitor::OnSuspend() {
   CancelPendingHistogramReporting();
 }

 void PowerUsageMonitor::Observe(int type,
                                 const NotificationSource& source,
                                 const NotificationDetails& details) {
   RenderProcessHost* rph = Source<RenderProcessHost>(source).ptr();
   OnRenderProcessNotification(type, rph->GetID());
 }

 void PowerUsageMonitor::CancelPendingHistogramReporting() {
   // Cancel any in-progress histogram reports and reporting of discharge UMA.
   system_interface_->CancelPendingHistogramReports();
 }

 }  // namespace content
	// Copyright 2014 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/power_usage_monitor_impl.h"

	#include <stddef.h>
	#include <utility>

	#include "base/bind.h"
	#include "base/lazy_instance.h"
	#include "base/logging.h"
	#include "base/macros.h"
	#include "base/metrics/histogram_macros.h"
	#include "base/strings/stringprintf.h"
	#include "base/sys_info.h"
	#include "content/public/browser/browser_thread.h"
	#include "content/public/browser/notification_service.h"
	#include "content/public/browser/notification_source.h"
	#include "content/public/browser/notification_types.h"
	#include "content/public/browser/power_usage_monitor.h"
	#include "content/public/browser/render_process_host.h"

	namespace content {

	namespace {

	// Wait this long after power on before enabling power usage monitoring.
	const int kMinUptimeMinutes = 30;

	// Minimum discharge time after which we collect the discharge rate.
	const int kMinDischargeMinutes = 30;

	class PowerUsageMonitorSystemInterface
	: public PowerUsageMonitor::SystemInterface {
	public:
	explicit PowerUsageMonitorSystemInterface(PowerUsageMonitor* owner)
	: power_usage_monitor_(owner),
	weak_ptr_factory_(this) {}
	~PowerUsageMonitorSystemInterface() override {}

	void ScheduleHistogramReport(base::TimeDelta delay) override {
	BrowserThread::PostDelayedTask(
	BrowserThread::UI,
	FROM_HERE,
	base::Bind(
	&PowerUsageMonitorSystemInterface::ReportBatteryLevelHistogram,
	weak_ptr_factory_.GetWeakPtr(),
	Now(),
	delay),
	delay);
	}

	void CancelPendingHistogramReports() override {
	weak_ptr_factory_.InvalidateWeakPtrs();
	}

	void RecordDischargePercentPerHour(int percent_per_hour) override {
	UMA_HISTOGRAM_PERCENTAGE("Power.BatteryDischargePercentPerHour",
	percent_per_hour);
	}

	base::Time Now() override { return base::Time::Now(); }

	protected:
	void ReportBatteryLevelHistogram(base::Time start_time,
	base::TimeDelta discharge_time) {
	// It's conceivable that the code to cancel pending histogram reports on
	// system suspend, will only get called after the system has woken up.
	// To mitigage this, check whether more time has passed than expected and
	// abort histogram recording in this case.

	// Delayed tasks are subject to timer coalescing and can fire anywhere from
	// delay -> delay * 1.5) . In most cases, the OS should fire the task
	// at the next wakeup and not as late as it can.
	// A threshold of 2 minutes is used, since that should be large enough to
	// take the slop factor due to coalescing into account.
	base::TimeDelta threshold = discharge_time +
	base::TimeDelta::FromMinutes(2);
	if ((Now() - start_time) > threshold) {
	return;
	}

	const std::string histogram_name = base::StringPrintf(
	"Power.BatteryDischarge_%d", discharge_time.InMinutes());
	base::HistogramBase* histogram =
	base::Histogram::FactoryGet(histogram_name,
	1,
	100,
	101,
	base::Histogram::kUmaTargetedHistogramFlag);
	double discharge_amount = power_usage_monitor_->discharge_amount();
	histogram->Add(discharge_amount * 100);
	}

	private:
	PowerUsageMonitor* power_usage_monitor_; // Not owned.

	// Used to cancel in progress delayed tasks.
	base::WeakPtrFactory<PowerUsageMonitorSystemInterface> weak_ptr_factory_;
	};

	} // namespace

	void StartPowerUsageMonitor() {
	static base::LazyInstance<PowerUsageMonitor>::Leaky monitor =
	LAZY_INSTANCE_INITIALIZER;
	monitor.Get().Start();
	}

	PowerUsageMonitor::PowerUsageMonitor()
	: callback_(base::Bind(&PowerUsageMonitor::OnBatteryStatusUpdate,
	base::Unretained(this))),
	system_interface_(new PowerUsageMonitorSystemInterface(this)),
	started_(false),
	tracking_discharge_(false),
	on_battery_power_(false),
	initial_battery_level_(0),
	current_battery_level_(0) {
	}

	PowerUsageMonitor::~PowerUsageMonitor() {
	if (started_)
	base::PowerMonitor::Get()->RemoveObserver(this);
	}

	void PowerUsageMonitor::Start() {
	// Power monitoring may be delayed based on uptime, but renderer process
	// lifetime tracking needs to start immediately so processes created before
	// then are accounted for.
	registrar_.Add(this,
	NOTIFICATION_RENDERER_PROCESS_CREATED,
	NotificationService::AllBrowserContextsAndSources());
	registrar_.Add(this,
	NOTIFICATION_RENDERER_PROCESS_CLOSED,
	NotificationService::AllBrowserContextsAndSources());
	subscription_ =
	device::BatteryStatusService::GetInstance()->AddCallback(callback_);

	// Delay initialization until the system has been up for a while.
	// This is to mitigate the effect of increased power draw during system start.
	base::TimeDelta uptime = base::SysInfo::Uptime();
	base::TimeDelta min_uptime = base::TimeDelta::FromMinutes(kMinUptimeMinutes);
	if (uptime < min_uptime) {
	base::TimeDelta delay = min_uptime - uptime;
	BrowserThread::PostDelayedTask(
	BrowserThread::UI,
	FROM_HERE,
	base::Bind(&PowerUsageMonitor::StartInternal, base::Unretained(this)),
	delay);
	} else {
	StartInternal();
	}
	}

	void PowerUsageMonitor::StartInternal() {
	DCHECK(!started_);
	started_ = true;

	// PowerMonitor is used to get suspend/resume notifications.
	base::PowerMonitor::Get()->AddObserver(this);
	}

	void PowerUsageMonitor::DischargeStarted(double battery_level) {
	on_battery_power_ = true;

	// If all browser windows are closed, don't report power metrics since
	// Chrome's power draw is likely not significant.
	if (live_renderer_ids_.empty())
	return;

	// Cancel any in-progress ReportBatteryLevelHistogram() calls.
	system_interface_->CancelPendingHistogramReports();

	tracking_discharge_ = true;
	start_discharge_time_ = system_interface_->Now();

	initial_battery_level_ = battery_level;
	current_battery_level_ = battery_level;

	const int kBatteryReportingIntervalMinutes[] = {5, 15, 30};
	for (auto reporting_interval : kBatteryReportingIntervalMinutes) {
	base::TimeDelta delay = base::TimeDelta::FromMinutes(reporting_interval);
	system_interface_->ScheduleHistogramReport(delay);
	}
	}

	void PowerUsageMonitor::WallPowerConnected(double battery_level) {
	on_battery_power_ = false;

	if (tracking_discharge_) {
	DCHECK(!start_discharge_time_.is_null());
	base::TimeDelta discharge_time =
	system_interface_->Now() - start_discharge_time_;

	if (discharge_time.InMinutes() > kMinDischargeMinutes) {
	// Record the rate at which the battery discharged over the entire period
	// the system was on battery power.
	double discharge_hours = discharge_time.InSecondsF() / 3600.0;
	int percent_per_hour =
	floor(((discharge_amount() / discharge_hours) * 100.0) + 0.5);
	system_interface_->RecordDischargePercentPerHour(percent_per_hour);
	}
	}

	// Cancel any in-progress ReportBatteryLevelHistogram() calls.
	system_interface_->CancelPendingHistogramReports();

	initial_battery_level_ = 0;
	current_battery_level_ = 0;
	start_discharge_time_ = base::Time();
	tracking_discharge_ = false;
	}

	void PowerUsageMonitor::OnBatteryStatusUpdate(
	const device::BatteryStatus& status) {
	bool now_on_battery_power = (status.charging == 0);
	bool was_on_battery_power = on_battery_power_;
	double battery_level = status.level;

	if (now_on_battery_power == was_on_battery_power) {
	if (now_on_battery_power)
	current_battery_level_ = battery_level;
	return;
	} else if (now_on_battery_power) { // Wall power disconnected.
	DischargeStarted(battery_level);
	} else { // Wall power connected.
	WallPowerConnected(battery_level);
	}
	}

	void PowerUsageMonitor::OnRenderProcessNotification(int type, int rph_id) {
	size_t previous_num_live_renderers = live_renderer_ids_.size();

	if (type == NOTIFICATION_RENDERER_PROCESS_CREATED) {
	live_renderer_ids_.insert(rph_id);
	} else if (type == NOTIFICATION_RENDERER_PROCESS_CLOSED) {
	live_renderer_ids_.erase(rph_id);
	} else {
	NOTREACHED() << "Unexpected notification type: " << type;
	}

	if (live_renderer_ids_.empty() && previous_num_live_renderers != 0) {
	// All render processes have died.
	CancelPendingHistogramReporting();
	tracking_discharge_ = false;
	}

	}

	void PowerUsageMonitor::SetSystemInterfaceForTest(
	std::unique_ptr<SystemInterface> interface) {
	system_interface_ = std::move(interface);
	}

	void PowerUsageMonitor::OnPowerStateChange(bool on_battery_power) {
	}

	void PowerUsageMonitor::OnResume() {
	}

	void PowerUsageMonitor::OnSuspend() {
	CancelPendingHistogramReporting();
	}

	void PowerUsageMonitor::Observe(int type,
	const NotificationSource& source,
	const NotificationDetails& details) {
	RenderProcessHost* rph = Source<RenderProcessHost>(source).ptr();
	OnRenderProcessNotification(type, rph->GetID());
	}

	void PowerUsageMonitor::CancelPendingHistogramReporting() {
	// Cancel any in-progress histogram reports and reporting of discharge UMA.
	system_interface_->CancelPendingHistogramReports();
	}

	} // namespace content