| // Copyright 2018 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 "chrome/browser/data_use_measurement/chrome_data_use_measurement.h" |
| |
| #include "base/bind.h" |
| #include "base/bind_helpers.h" |
| #include "base/macros.h" |
| #include "base/metrics/histogram_macros.h" |
| #include "base/numerics/safe_conversions.h" |
| #include "base/task/post_task.h" |
| #include "base/task/task_traits.h" |
| #include "build/build_config.h" |
| #include "chrome/browser/browser_process.h" |
| #include "components/data_use_measurement/core/data_use_ascriber.h" |
| #include "components/data_use_measurement/core/url_request_classifier.h" |
| #include "components/metrics/data_use_tracker.h" |
| #include "content/public/browser/browser_task_traits.h" |
| #include "content/public/browser/browser_thread.h" |
| #include "content/public/browser/network_service_instance.h" |
| #include "services/network/public/cpp/features.h" |
| |
| using content::BrowserThread; |
| |
| namespace data_use_measurement { |
| |
| namespace { |
| // Global instance to be used when network service is enabled, this will never |
| // be deleted. When network service is disabled, this should always be null. |
| ChromeDataUseMeasurement* g_chrome_data_use_measurement = nullptr; |
| |
| DataUseUserData::DataUseContentType GetContentType(const std::string& mime_type, |
| bool is_main_frame_resource, |
| bool is_app_background, |
| bool is_tab_visible) { |
| if (mime_type == "text/html") |
| return is_main_frame_resource ? DataUseUserData::MAIN_FRAME_HTML |
| : DataUseUserData::NON_MAIN_FRAME_HTML; |
| if (mime_type == "text/css") |
| return DataUseUserData::CSS; |
| if (base::StartsWith(mime_type, "image/", base::CompareCase::SENSITIVE)) |
| return DataUseUserData::IMAGE; |
| if (base::EndsWith(mime_type, "javascript", base::CompareCase::SENSITIVE) || |
| base::EndsWith(mime_type, "ecmascript", base::CompareCase::SENSITIVE)) { |
| return DataUseUserData::JAVASCRIPT; |
| } |
| if (mime_type.find("font") != std::string::npos) |
| return DataUseUserData::FONT; |
| if (base::StartsWith(mime_type, "audio/", base::CompareCase::SENSITIVE)) |
| return is_app_background |
| ? DataUseUserData::AUDIO_APPBACKGROUND |
| : (!is_tab_visible ? DataUseUserData::AUDIO_TABBACKGROUND |
| : DataUseUserData::AUDIO); |
| if (base::StartsWith(mime_type, "video/", base::CompareCase::SENSITIVE)) |
| return is_app_background |
| ? DataUseUserData::VIDEO_APPBACKGROUND |
| : (!is_tab_visible ? DataUseUserData::VIDEO_TABBACKGROUND |
| : DataUseUserData::VIDEO); |
| return DataUseUserData::OTHER; |
| } |
| |
| } // namespace |
| |
| // static |
| void ChromeDataUseMeasurement::CreateInstance(PrefService* local_state) { |
| DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) || |
| !BrowserThread::IsThreadInitialized(BrowserThread::UI)); |
| |
| DCHECK(!g_chrome_data_use_measurement); |
| |
| // Do not create when NetworkService is disabled, since data use of URLLoader |
| // is reported via the network delegate callbacks. |
| if (!base::FeatureList::IsEnabled(network::features::kNetworkService)) |
| return; |
| |
| g_chrome_data_use_measurement = new ChromeDataUseMeasurement( |
| nullptr, nullptr, content::GetNetworkConnectionTracker(), local_state); |
| } |
| |
| // static |
| ChromeDataUseMeasurement* ChromeDataUseMeasurement::GetInstance() { |
| DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) || |
| !BrowserThread::IsThreadInitialized(BrowserThread::UI)); |
| |
| return g_chrome_data_use_measurement; |
| } |
| |
| ChromeDataUseMeasurement::ChromeDataUseMeasurement( |
| std::unique_ptr<URLRequestClassifier> url_request_classifier, |
| DataUseAscriber* ascriber, |
| network::NetworkConnectionTracker* network_connection_tracker, |
| PrefService* local_state) |
| : DataUseMeasurement(std::move(url_request_classifier), |
| ascriber, |
| network_connection_tracker), |
| local_state_(local_state) { |
| DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
| } |
| |
| void ChromeDataUseMeasurement::UpdateDataUseToMetricsService( |
| int64_t total_bytes, |
| bool is_cellular, |
| bool is_metrics_service_usage) { |
| DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
| // Update data use of user traffic and services distinguishing cellular and |
| // metrics services data use. |
| UpdateMetricsUsagePrefsOnUIThread(total_bytes, is_cellular, |
| is_metrics_service_usage); |
| } |
| |
| void ChromeDataUseMeasurement::ReportNetworkServiceDataUse( |
| int32_t network_traffic_annotation_id_hash, |
| int64_t recv_bytes, |
| int64_t sent_bytes) { |
| DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
| DCHECK(base::FeatureList::IsEnabled(network::features::kNetworkService)); |
| // Negative byte numbres is not a critical problem (i.e. should have no security implications) but |
| // is not expected. TODO(rajendrant): remove these DCHECKs or consider using uint in Mojo instead. |
| DCHECK_GE(recv_bytes, 0); |
| DCHECK_GE(sent_bytes, 0); |
| |
| bool is_user_request = |
| DataUseMeasurement::IsUserRequest(network_traffic_annotation_id_hash); |
| bool is_metrics_service_request = |
| IsMetricsServiceRequest(network_traffic_annotation_id_hash); |
| UpdateMetricsUsagePrefs(recv_bytes, IsCurrentNetworkCellular(), |
| is_metrics_service_request); |
| UpdateMetricsUsagePrefs(sent_bytes, IsCurrentNetworkCellular(), |
| is_metrics_service_request); |
| if (!is_user_request) { |
| ReportDataUsageServices(network_traffic_annotation_id_hash, UPSTREAM, |
| CurrentAppState(), sent_bytes); |
| ReportDataUsageServices(network_traffic_annotation_id_hash, DOWNSTREAM, |
| CurrentAppState(), recv_bytes); |
| } |
| if (!is_user_request || DataUseMeasurement::IsUserDownloadsRequest( |
| network_traffic_annotation_id_hash)) { |
| for (auto& observer : services_data_use_observer_list_) |
| observer.OnServicesDataUse(network_traffic_annotation_id_hash, recv_bytes, |
| sent_bytes); |
| } |
| UMA_HISTOGRAM_COUNTS_1M("DataUse.BytesReceived.Delegate", recv_bytes); |
| UMA_HISTOGRAM_COUNTS_1M("DataUse.BytesSent.Delegate", sent_bytes); |
| #if defined(OS_ANDROID) |
| bytes_transferred_since_last_traffic_stats_query_ += recv_bytes + sent_bytes; |
| MaybeRecordNetworkBytesOS(); |
| #endif |
| } |
| |
| void ChromeDataUseMeasurement::ReportUserTrafficDataUse(bool is_tab_visible, |
| int64_t recv_bytes) { |
| RecordTrafficSizeMetric(true, true, is_tab_visible, recv_bytes); |
| } |
| |
| void ChromeDataUseMeasurement::RecordContentTypeMetric( |
| const std::string& mime_type, |
| bool is_main_frame_resource, |
| bool is_tab_visible, |
| int64_t recv_bytes) { |
| DataUseUserData::DataUseContentType content_type = GetContentType( |
| mime_type, is_main_frame_resource, |
| CurrentAppState() == DataUseUserData::BACKGROUND, is_tab_visible); |
| UMA_HISTOGRAM_SCALED_ENUMERATION("DataUse.ContentType.UserTrafficKB", |
| content_type, recv_bytes, 1024); |
| } |
| |
| void ChromeDataUseMeasurement::UpdateMetricsUsagePrefs( |
| int64_t total_bytes, |
| bool is_cellular, |
| bool is_metrics_service_usage) { |
| PrefService* local_state; |
| if (base::FeatureList::IsEnabled(network::features::kNetworkService)) { |
| DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
| local_state = local_state_; |
| } else { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| local_state = g_browser_process->local_state(); |
| } |
| DCHECK(local_state); |
| |
| metrics::DataUseTracker::UpdateMetricsUsagePrefs( |
| base::saturated_cast<int>(total_bytes), is_cellular, |
| is_metrics_service_usage, local_state); |
| } |
| |
| // This function is for forwarding metrics usage pref changes to the metrics |
| // service on the appropriate thread. |
| // TODO(gayane): Reduce the frequency of posting tasks from IO to UI thread. |
| void ChromeDataUseMeasurement::UpdateMetricsUsagePrefsOnUIThread( |
| int64_t total_bytes, |
| bool is_cellular, |
| bool is_metrics_service_usage) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::IO); |
| |
| base::PostTaskWithTraits( |
| FROM_HERE, content::BrowserThread::UI, |
| base::BindOnce(&ChromeDataUseMeasurement::UpdateMetricsUsagePrefs, |
| base::Unretained(this), total_bytes, is_cellular, |
| is_metrics_service_usage)); |
| } |
| |
| } // namespace data_use_measurement |
