blob: 64b9ee3a61826304e0423cbf46081ef82f817945 [file] [log] [blame]
// Copyright 2015 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 <stddef.h>
#include <memory>
#include <set>
#include "base/callback.h"
#include "base/macros.h"
#include "base/memory/weak_ptr.h"
#include "base/scoped_observer.h"
#include "base/time/time.h"
#include "extensions/browser/deferred_start_render_host_observer.h"
#include "extensions/browser/extension_host_queue.h"
namespace extensions {
// An ExtensionHostQueue which just monitors, and later reports, how many
// ExtensionHosts are being loaded for some period of time.
class LoadMonitoringExtensionHostQueue
: public ExtensionHostQueue,
public DeferredStartRenderHostObserver {
// Construction for testing.
// Allows overriding the default timeout and triggering a callback when
// monitoring has finished (timeout has elapsed and UMA is logged).
using FinishedCallback = base::Callback<void(size_t, // num_queued
size_t, // max_loaded
size_t, // max_awaiting_loading
size_t // max_active_loading
LoadMonitoringExtensionHostQueue(std::unique_ptr<ExtensionHostQueue> delegate,
base::TimeDelta monitor_time,
const FinishedCallback& finished_callback);
// Production code should use this constructor.
// Monitoring will not start until the first Add()ed
// DeferredStartRenderHost starts loading, or StartMonitoring() is called.
explicit LoadMonitoringExtensionHostQueue(
std::unique_ptr<ExtensionHostQueue> delegate);
~LoadMonitoringExtensionHostQueue() override;
// Starts monitoring.
// This can be called multiple times, but it has no effect if monitoring has
// already started (or finished). Monitoring cannot be restarted.
// Note that monitoring will automatically start when Add() is called, so it
// may not be necessary to call this at all.
void StartMonitoring();
// ExtensionHostQueue:
void Add(DeferredStartRenderHost* host) override;
void Remove(DeferredStartRenderHost* host) override;
// DeferredStartRenderHostObserver, public to be triggered by tests:
void OnDeferredStartRenderHostDidStartFirstLoad(
const DeferredStartRenderHost* host) override;
void OnDeferredStartRenderHostDidStopFirstLoad(
const DeferredStartRenderHost* host) override;
void OnDeferredStartRenderHostDestroyed(
const DeferredStartRenderHost* host) override;
// Starts/finishes monitoring |host|, though either will have no effect if
// monitoring has already finished.
void StartMonitoringHost(const DeferredStartRenderHost* host);
void FinishMonitoringHost(const DeferredStartRenderHost* host);
// Called when monitoring should finish. Metrics are recorded, and from this
// point on no monitoring will take place.
void FinishMonitoring();
// Delegate actually loading DeferredStartRenderHosts to another queue.
std::unique_ptr<ExtensionHostQueue> delegate_;
// The amount of time to monitor for. By default this is 1 minute, but it can
// be overriden by tests.
base::TimeDelta monitor_time_;
// A callback to run when monitoring has finished. Intended for testing.
FinishedCallback finished_callback_;
// The hosts which are waiting to start loading.
std::set<const DeferredStartRenderHost*> awaiting_loading_;
// The hosts which are currently loading.
std::set<const DeferredStartRenderHost*> active_loading_;
// True if this has started monitoring.
bool started_;
// Metrics:
// The total number of hosts that were added to the queue.
size_t num_queued_;
// The total number of hosts that started loading.
size_t num_loaded_;
// The maximum number of hosts waiting to load at the same time.
size_t max_awaiting_loading_;
// The maximum number of hosts that were loading at the same time.
size_t max_active_loading_;
base::WeakPtrFactory<LoadMonitoringExtensionHostQueue> weak_ptr_factory_;
} // namespace extensions