blob: e16a73881411140b860852510602c352a8137f0d [file] [log] [blame]
// Copyright 2017 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 <memory>
#include <string>
#include <vector>
#include "base/containers/flat_set.h"
#include "base/macros.h"
#include "base/memory/weak_ptr.h"
#include "base/time/time.h"
#include "components/performance_manager/graph/node_attached_data.h"
#include "components/performance_manager/graph/node_base.h"
#include "components/performance_manager/public/graph/page_node.h"
#include "components/performance_manager/public/web_contents_proxy.h"
#include "url/gurl.h"
namespace performance_manager {
class FrameNodeImpl;
class PageNodeImpl
: public PublicNodeImpl<PageNodeImpl, PageNode>,
public TypedNodeBase<PageNodeImpl, PageNode, PageNodeObserver> {
static constexpr NodeTypeEnum Type() { return NodeTypeEnum::kPage; }
PageNodeImpl(GraphImpl* graph,
const WebContentsProxy& contents_proxy,
const std::string& browser_context_id,
const GURL& visible_url,
bool is_visible,
bool is_audible);
~PageNodeImpl() override;
// Returns the web contents associated with this page node. It is valid to
// call this function on any thread but the weak pointer must only be
// dereferenced on the UI thread.
const WebContentsProxy& contents_proxy() const;
void SetIsVisible(bool is_visible);
void SetIsAudible(bool is_audible);
void SetIsLoading(bool is_loading);
void SetUkmSourceId(ukm::SourceId ukm_source_id);
void OnFaviconUpdated();
void OnTitleUpdated();
void OnMainFrameNavigationCommitted(bool same_document,
base::TimeTicks navigation_committed_time,
int64_t navigation_id,
const GURL& url,
const std::string& contents_mime_type);
// Returns the average CPU usage that can be attributed to this page over the
// last measurement period. CPU usage is expressed as the average percentage
// of cores occupied over the last measurement interval. One core fully
// occupied would be 100, while two cores at 5% each would be 10.
// TODO(chrisha): Make this 1.0 for 100%, and 0.1 for 10%.
double GetCPUUsage() const;
// Returns 0 if no navigation has happened, otherwise returns the time since
// the last navigation commit.
base::TimeDelta TimeSinceLastNavigation() const;
// Returns the time since the last visibility change, it should always have a
// value since we set the visibility property when we create a
// page node.
base::TimeDelta TimeSinceLastVisibilityChange() const;
// Returns the current main frame node (if there is one), otherwise returns
// any of the potentially multiple main frames that currently exist. If there
// are no main frames at the moment, returns nullptr.
FrameNodeImpl* GetMainFrameNodeImpl() const;
// Accessors.
const std::string& browser_context_id() const;
bool is_visible() const;
bool is_audible() const;
bool is_loading() const;
ukm::SourceId ukm_source_id() const;
LifecycleState lifecycle_state() const;
InterventionPolicy origin_trial_freeze_policy() const;
bool is_holding_weblock() const;
bool is_holding_indexeddb_lock() const;
const base::flat_set<FrameNodeImpl*>& main_frame_nodes() const;
base::TimeTicks usage_estimate_time() const;
base::TimeDelta cumulative_cpu_usage_estimate() const;
uint64_t private_footprint_kb_estimate() const;
bool page_almost_idle() const;
const GURL& main_frame_url() const;
int64_t navigation_id() const;
const std::string& contents_mime_type() const;
bool had_form_interaction() const;
void set_usage_estimate_time(base::TimeTicks usage_estimate_time);
void set_cumulative_cpu_usage_estimate(
base::TimeDelta cumulative_cpu_usage_estimate);
void set_private_footprint_kb_estimate(
uint64_t private_footprint_kb_estimate);
void set_has_nonempty_beforeunload(bool has_nonempty_beforeunload);
void SetLifecycleStateForTesting(LifecycleState lifecycle_state) {
void SetPageAlmostIdleForTesting(bool page_almost_idle) {
void SetIsHoldingWebLockForTesting(bool is_holding_weblock) {
void SetHadFormInteractionForTesting(bool had_form_interaction) {
base::WeakPtr<PageNodeImpl> GetWeakPtr() {
return weak_factory_.GetWeakPtr();
friend class FrameNodeImpl;
friend class PageAggregatorAccess;
friend class FrozenFrameAggregatorAccess;
friend class PageAlmostIdleAccess;
// PageNode implementation:
const std::string& GetBrowserContextID() const override;
bool IsPageAlmostIdle() const override;
bool IsVisible() const override;
base::TimeDelta GetTimeSinceLastVisibilityChange() const override;
bool IsAudible() const override;
bool IsLoading() const override;
ukm::SourceId GetUkmSourceID() const override;
LifecycleState GetLifecycleState() const override;
InterventionPolicy GetOriginTrialFreezePolicy() const override;
bool IsHoldingWebLock() const override;
bool IsHoldingIndexedDBLock() const override;
int64_t GetNavigationID() const override;
const std::string& GetContentsMimeType() const override;
base::TimeDelta GetTimeSinceLastNavigation() const override;
const FrameNode* GetMainFrameNode() const override;
const base::flat_set<const FrameNode*> GetMainFrameNodes() const override;
const GURL& GetMainFrameUrl() const override;
bool HadFormInteraction() const override;
const WebContentsProxy& GetContentsProxy() const override;
void AddFrame(FrameNodeImpl* frame_node);
void RemoveFrame(FrameNodeImpl* frame_node);
void JoinGraph() override;
void LeaveGraph() override;
void SetPageAlmostIdle(bool page_almost_idle);
void SetLifecycleState(LifecycleState lifecycle_state);
void SetOriginTrialFreezePolicy(InterventionPolicy policy);
void SetIsHoldingWebLock(bool is_holding_weblock);
void SetIsHoldingIndexedDBLock(bool is_holding_indexeddb_lock);
void SetHadFormInteraction(bool had_form_interaction);
// The WebContentsProxy associated with this page.
const WebContentsProxy contents_proxy_;
// The main frame nodes of this page. There can be more than one main frame
// in a page, among other reasons because during main frame navigation, the
// pending navigation will coexist with the existing main frame until it's
// committed.
base::flat_set<FrameNodeImpl*> main_frame_nodes_;
// The total count of frames that tally up to this page.
size_t frame_node_count_ = 0;
// The last time at which the page visibility changed.
base::TimeTicks visibility_change_time_;
// The last time at which a main frame navigation was committed.
base::TimeTicks navigation_committed_time_;
// The time the most recent resource usage estimate applies to.
base::TimeTicks usage_estimate_time_;
// The most current CPU usage estimate. Note that this estimate is most
// generously described as "piecewise linear", as it attributes the CPU
// cost incurred since the last measurement was made equally to pages
// hosted by a process. If, e.g. a frame has come into existence and vanished
// from a given process between measurements, the entire cost to that frame
// will be mis-attributed to other frames hosted in that process.
base::TimeDelta cumulative_cpu_usage_estimate_;
// The most current memory footprint estimate.
uint64_t private_footprint_kb_estimate_ = 0;
// Indicates whether or not this page has a non-empty beforeunload handler.
// This is an aggregation of the same value on each frame in the page's frame
// tree. The aggregation is made at the moment all frames associated with a
// page have transition to frozen.
bool has_nonempty_beforeunload_ = false;
// The URL the main frame last committed, or the initial URL a page was
// initialized with. The latter case is distinguished by a zero navigation ID.
NotifiesOnlyOnChanges<GURL, &PageNodeObserver::OnMainFrameUrlChanged>
// The unique ID of the navigation handle the main frame last committed, or
// zero if the page has never committed a navigation.
int64_t navigation_id_ = 0;
// The MIME type of the content associated with the last committed navigation
// event for the main frame of this page or an empty string if the page has
// never committed a navigation
std::string contents_mime_type_;
// The unique ID of the browser context that this page belongs to.
const std::string browser_context_id_;
// Page almost idle state. This is the output that is driven by the
// PageAlmostIdleDecorator.
NotifiesOnlyOnChanges<bool, &PageNodeObserver::OnPageAlmostIdleChanged>
// Whether or not the page is visible. Driven by browser instrumentation.
// Initialized on construction.
// Whether or not the page is audible. Driven by browser instrumentation.
// Initialized on construction.
// The loading state. This is driven by instrumentation in the browser
// process.
// The UKM source ID associated with the URL of the main frame of this page.
// The lifecycle state of this page. This is aggregated from the lifecycle
// state of each frame in the frame tree.
// The origin trial freeze policy of this page. This is aggregated from the
// origin trial freeze policy of each current frame in the frame tree.
// Indicates if at least one frame of the page is currently holding a WebLock.
// Indicates if at least one frame of the page is currently holding an
// IndexedDB lock.
// Indicates if at least one frame of the page has received some form
// interactions.
// Storage for PageAlmostIdle user data.
std::unique_ptr<NodeAttachedData> page_almost_idle_data_;
// Inline storage for FrozenFrameAggregator user data.
InternalNodeAttachedDataStorage<sizeof(uintptr_t) + 8> frozen_frame_data_;
// Inline storage for PageAggregatorAccess user data.
InternalNodeAttachedDataStorage<sizeof(uintptr_t) + 24> page_aggregator_data_;
base::WeakPtrFactory<PageNodeImpl> weak_factory_{this};
} // namespace performance_manager