// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "android_webview/browser/metrics/visibility_metrics_logger.h"
#include "base/containers/contains.h"
#include "base/metrics/histogram.h"
#include "base/metrics/histogram_base.h"
#include "base/time/time.h"
#include "base/trace_event/trace_event.h"
#include "base/trace_event/typed_macros.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/common/url_constants.h"
using content::BrowserThread;
namespace android_webview {
namespace {
const char* SchemeEnumToString(VisibilityMetricsLogger::Scheme scheme) {
switch (scheme) {
case VisibilityMetricsLogger::Scheme::kEmpty:
return "empty";
case VisibilityMetricsLogger::Scheme::kUnknown:
return "unknown";
case VisibilityMetricsLogger::Scheme::kHttp:
return url::kHttpScheme;
case VisibilityMetricsLogger::Scheme::kHttps:
return url::kHttpsScheme;
case VisibilityMetricsLogger::Scheme::kFile:
return url::kFileScheme;
case VisibilityMetricsLogger::Scheme::kFtp:
return url::kFtpScheme;
case VisibilityMetricsLogger::Scheme::kData:
return url::kDataScheme;
case VisibilityMetricsLogger::Scheme::kJavaScript:
return url::kJavaScriptScheme;
case VisibilityMetricsLogger::Scheme::kAbout:
return url::kAboutScheme;
case VisibilityMetricsLogger::Scheme::kChrome:
return content::kChromeUIScheme;
case VisibilityMetricsLogger::Scheme::kBlob:
return url::kBlobScheme;
case VisibilityMetricsLogger::Scheme::kContent:
return url::kContentScheme;
case VisibilityMetricsLogger::Scheme::kIntent:
return "intent";
default:
NOTREACHED();
}
}
// Have bypassed the usual macros here because they do not support a
// means to increment counters by more than 1 per call.
base::HistogramBase* GetOrCreateHistogramForDurationTracking(
const std::string& name,
int max_value) {
return base::Histogram::FactoryGet(
name, 1, max_value + 1, max_value + 2,
base::HistogramBase::kUmaTargetedHistogramFlag);
}
// base::Histogram::FactoryGet would internally convert to std::string anyway,
// this overload is for convenience.
base::HistogramBase* GetOrCreateHistogramForDurationTracking(const char* name,
int max_value) {
return GetOrCreateHistogramForDurationTracking(std::string(name), max_value);
}
base::HistogramBase* GetGlobalVisibilityHistogram() {
static base::HistogramBase* histogram(GetOrCreateHistogramForDurationTracking(
"Android.WebView.Visibility.Global",
static_cast<int>(VisibilityMetricsLogger::Visibility::kMaxValue)));
return histogram;
}
base::HistogramBase* GetPerWebViewVisibilityHistogram() {
static base::HistogramBase* histogram(GetOrCreateHistogramForDurationTracking(
"Android.WebView.Visibility.PerWebView",
static_cast<int>(VisibilityMetricsLogger::Visibility::kMaxValue)));
return histogram;
}
void LogGlobalVisibleScheme(VisibilityMetricsLogger::Scheme scheme,
int32_t seconds) {
static base::HistogramBase* histogram(GetOrCreateHistogramForDurationTracking(
"Android.WebView.VisibleScheme.Global",
static_cast<int>(VisibilityMetricsLogger::Scheme::kMaxValue)));
histogram->AddCount(static_cast<int32_t>(scheme), seconds);
}
void LogPerWebViewVisibleScheme(VisibilityMetricsLogger::Scheme scheme,
int32_t seconds) {
static base::HistogramBase* histogram(GetOrCreateHistogramForDurationTracking(
"Android.WebView.VisibleScheme.PerWebView",
static_cast<int>(VisibilityMetricsLogger::Scheme::kMaxValue)));
histogram->AddCount(static_cast<int32_t>(scheme), seconds);
}
void LogGlobalVisibleScreenCoverage(int percentage, int32_t seconds) {
static base::HistogramBase* histogram(GetOrCreateHistogramForDurationTracking(
"Android.WebView.VisibleScreenCoverage.Global", 100));
histogram->AddCount(percentage, seconds);
}
void LogPerWebViewVisibleScreenCoverage(int percentage, int32_t seconds) {
static base::HistogramBase* histogram(GetOrCreateHistogramForDurationTracking(
"Android.WebView.VisibleScreenCoverage.PerWebView", 100));
histogram->AddCount(percentage, seconds);
}
void LogPerSchemeVisibleScreenCoverage(VisibilityMetricsLogger::Scheme scheme,
int percentage,
int32_t seconds) {
GetOrCreateHistogramForDurationTracking(
std::string("Android.WebView.VisibleScreenCoverage.PerWebView.") +
SchemeEnumToString(scheme),
100)
->AddCount(percentage, seconds);
}
} // anonymous namespace
// static
VisibilityMetricsLogger::Scheme VisibilityMetricsLogger::SchemeStringToEnum(
const std::string& scheme) {
if (scheme.empty())
return Scheme::kEmpty;
if (scheme == url::kHttpScheme)
return Scheme::kHttp;
if (scheme == url::kHttpsScheme)
return Scheme::kHttps;
if (scheme == url::kFileScheme)
return Scheme::kFile;
if (scheme == url::kFtpScheme)
return Scheme::kFtp;
if (scheme == url::kDataScheme)
return Scheme::kData;
if (scheme == url::kJavaScriptScheme)
return Scheme::kJavaScript;
if (scheme == url::kAboutScheme)
return Scheme::kAbout;
if (scheme == content::kChromeUIScheme)
return Scheme::kChrome;
if (scheme == url::kBlobScheme)
return Scheme::kBlob;
if (scheme == url::kContentScheme)
return Scheme::kContent;
if (scheme == "intent")
return Scheme::kIntent;
return Scheme::kUnknown;
}
VisibilityMetricsLogger::VisibilityMetricsLogger() {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
last_update_time_ = base::TimeTicks::Now();
}
VisibilityMetricsLogger::~VisibilityMetricsLogger() = default;
void VisibilityMetricsLogger::AddClient(Client* client) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
DCHECK(!base::Contains(client_visibility_, client));
UpdateDurations();
client_visibility_[client] = VisibilityInfo();
ProcessClientUpdate(client, client->GetVisibilityInfo(),
ClientAction::kAdded);
}
void VisibilityMetricsLogger::RemoveClient(Client* client) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
DCHECK(base::Contains(client_visibility_, client));
UpdateDurations();
ProcessClientUpdate(client, VisibilityInfo(), ClientAction::kRemoved);
client_visibility_.erase(client);
}
void VisibilityMetricsLogger::ClientVisibilityChanged(Client* client) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
DCHECK(base::Contains(client_visibility_, client));
UpdateDurations();
ProcessClientUpdate(client, client->GetVisibilityInfo(),
ClientAction::kVisibilityChanged);
}
void VisibilityMetricsLogger::UpdateScreenCoverage(
int global_percentage,
const std::vector<Scheme>& schemes,
const std::vector<int>& scheme_percentages) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
DCHECK(schemes.size() == scheme_percentages.size());
UpdateDurations();
DCHECK(global_percentage >= 0);
DCHECK(global_percentage <= 100);
global_coverage_percentage_ = global_percentage;
schemes_to_coverage_percentages_.clear();
for (size_t i = 0; i < schemes.size(); i++) {
DCHECK(scheme_percentages[i] >= 0);
DCHECK(scheme_percentages[i] <= 100);
schemes_to_coverage_percentages_.emplace(schemes[i], scheme_percentages[i]);
}
}
void VisibilityMetricsLogger::UpdateDurations() {
base::TimeTicks update_time = base::TimeTicks::Now();
base::TimeDelta delta = update_time - last_update_time_;
if (all_clients_visible_count_ > 0) {
all_clients_tracker_.any_webview_tracked_duration_ += delta;
} else {
all_clients_tracker_.no_webview_tracked_duration_ += delta;
}
all_clients_tracker_.per_webview_duration_ +=
delta * all_clients_visible_count_;
all_clients_tracker_.per_webview_untracked_duration_ +=
delta * (client_visibility_.size() - all_clients_visible_count_);
for (size_t i = 0; i < std::size(per_scheme_visible_counts_); i++) {
if (!per_scheme_visible_counts_[i])
continue;
per_scheme_trackers_[i].any_webview_tracked_duration_ += delta;
per_scheme_trackers_[i].per_webview_duration_ +=
delta * per_scheme_visible_counts_[i];
}
if (all_clients_visible_count_ > 0) {
global_coverage_percentage_durations_[global_coverage_percentage_] += delta;
for (auto& scheme_and_percentage : schemes_to_coverage_percentages_) {
schemes_to_percentages_to_durations_[scheme_and_percentage.first]
[scheme_and_percentage.second] +=
delta;
}
}
last_update_time_ = update_time;
}
bool VisibilityMetricsLogger::VisibilityInfo::IsVisible() const {
return view_attached && view_visible && window_visible;
}
void VisibilityMetricsLogger::ProcessClientUpdate(Client* client,
const VisibilityInfo& info,
ClientAction action) {
VisibilityInfo curr_info = client_visibility_[client];
bool was_visible = curr_info.IsVisible();
bool is_visible = info.IsVisible();
Scheme old_scheme = curr_info.scheme;
Scheme new_scheme = info.scheme;
client_visibility_[client] = info;
DCHECK(!was_visible || all_clients_visible_count_ > 0);
bool any_client_was_visible = all_clients_visible_count_ > 0;
if (action == ClientAction::kAdded) {
// Only emit the event if the WebView is visible so that the track gets the
// appropriate name.
// TODO(b/280334022): set the track name explicitly after the Perfetto SDK
// migration is finished (crbug/1006541).
if (is_visible) {
TRACE_EVENT_BEGIN("android_webview.timeline", "WebViewVisible",
perfetto::Track::FromPointer(client));
}
}
// If visibility changes or the client is removed, close the event
// corresponding to the previous visibility state.
if (action == ClientAction::kRemoved || was_visible != is_visible) {
TRACE_EVENT_END("android_webview.timeline",
perfetto::Track::FromPointer(client));
}
if (!was_visible && is_visible) {
if (action != ClientAction::kRemoved) {
TRACE_EVENT_BEGIN("android_webview.timeline", "WebViewVisible",
perfetto::Track::FromPointer(client));
}
++all_clients_visible_count_;
} else if (was_visible && !is_visible) {
if (action != ClientAction::kRemoved) {
TRACE_EVENT_BEGIN("android_webview.timeline", "WebViewInvisible",
perfetto::Track::FromPointer(client));
}
--all_clients_visible_count_;
}
if (was_visible)
per_scheme_visible_counts_[static_cast<size_t>(old_scheme)]--;
if (is_visible)
per_scheme_visible_counts_[static_cast<size_t>(new_scheme)]++;
bool any_client_is_visible = all_clients_visible_count_ > 0;
if (on_visibility_changed_callback_ &&
any_client_was_visible != any_client_is_visible) {
on_visibility_changed_callback_.Run(any_client_is_visible);
}
}
void VisibilityMetricsLogger::SetOnVisibilityChangedCallback(
OnVisibilityChangedCallback callback) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
on_visibility_changed_callback_ = std::move(callback);
}
void VisibilityMetricsLogger::RecordMetrics() {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
UpdateDurations();
RecordVisibilityMetrics();
RecordVisibleSchemeMetrics();
RecordScreenCoverageMetrics();
}
void VisibilityMetricsLogger::RecordVisibilityMetrics() {
int32_t any_webview_visible_seconds;
int32_t no_webview_visible_seconds;
int32_t total_webview_visible_seconds;
int32_t total_no_webview_visible_seconds;
any_webview_visible_seconds =
all_clients_tracker_.any_webview_tracked_duration_.InSeconds();
all_clients_tracker_.any_webview_tracked_duration_ -=
base::Seconds(any_webview_visible_seconds);
no_webview_visible_seconds =
all_clients_tracker_.no_webview_tracked_duration_.InSeconds();
all_clients_tracker_.no_webview_tracked_duration_ -=
base::Seconds(no_webview_visible_seconds);
total_webview_visible_seconds =
all_clients_tracker_.per_webview_duration_.InSeconds();
all_clients_tracker_.per_webview_duration_ -=
base::Seconds(total_webview_visible_seconds);
total_no_webview_visible_seconds =
all_clients_tracker_.per_webview_untracked_duration_.InSeconds();
all_clients_tracker_.per_webview_untracked_duration_ -=
base::Seconds(total_no_webview_visible_seconds);
if (any_webview_visible_seconds) {
GetGlobalVisibilityHistogram()->AddCount(
static_cast<int>(Visibility::kVisible), any_webview_visible_seconds);
}
if (no_webview_visible_seconds) {
GetGlobalVisibilityHistogram()->AddCount(
static_cast<int>(Visibility::kNotVisible), no_webview_visible_seconds);
}
if (total_webview_visible_seconds) {
GetPerWebViewVisibilityHistogram()->AddCount(
static_cast<int>(Visibility::kVisible), total_webview_visible_seconds);
}
if (total_no_webview_visible_seconds) {
GetPerWebViewVisibilityHistogram()->AddCount(
static_cast<int>(Visibility::kNotVisible),
total_no_webview_visible_seconds);
}
}
void VisibilityMetricsLogger::RecordVisibleSchemeMetrics() {
for (size_t i = 0; i < std::size(per_scheme_trackers_); i++) {
Scheme scheme = static_cast<Scheme>(i);
auto& tracker = per_scheme_trackers_[i];
int32_t any_webview_seconds =
tracker.any_webview_tracked_duration_.InSeconds();
if (any_webview_seconds) {
tracker.any_webview_tracked_duration_ -=
base::Seconds(any_webview_seconds);
LogGlobalVisibleScheme(scheme, any_webview_seconds);
}
int32_t per_webview_seconds = tracker.per_webview_duration_.InSeconds();
if (per_webview_seconds) {
tracker.per_webview_duration_ -= base::Seconds(per_webview_seconds);
LogPerWebViewVisibleScheme(scheme, per_webview_seconds);
}
}
}
void VisibilityMetricsLogger::RecordScreenCoverageMetrics() {
for (size_t i = 0; i < std::size(global_coverage_percentage_durations_);
i++) {
int32_t seconds = global_coverage_percentage_durations_[i].InSeconds();
if (seconds == 0)
continue;
global_coverage_percentage_durations_[i] -= base::Seconds(seconds);
LogGlobalVisibleScreenCoverage(i, seconds);
}
for (auto& scheme_and_map : schemes_to_percentages_to_durations_) {
for (auto& percentage_and_duration : scheme_and_map.second) {
int32_t seconds = percentage_and_duration.second.InSeconds();
if (seconds == 0)
continue;
percentage_and_duration.second -= base::Seconds(seconds);
LogPerWebViewVisibleScreenCoverage(percentage_and_duration.first,
seconds);
LogPerSchemeVisibleScreenCoverage(scheme_and_map.first,
percentage_and_duration.first, seconds);
}
}
}
} // namespace android_webview
Codebase Browser
chromium