| // 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 "components/consent_auditor/consent_auditor_impl.h" |
| |
| #include <memory> |
| #include <utility> |
| |
| #include "base/metrics/histogram_macros.h" |
| #include "base/sha1.h" |
| #include "base/values.h" |
| #include "components/consent_auditor/pref_names.h" |
| #include "components/prefs/pref_registry_simple.h" |
| #include "components/prefs/pref_service.h" |
| #include "components/prefs/scoped_user_pref_update.h" |
| #include "components/sync/driver/sync_driver_switches.h" |
| #include "components/sync/model/model_type_sync_bridge.h" |
| #include "components/sync/user_events/user_event_service.h" |
| |
| using ArcPlayTermsOfServiceConsent = |
| sync_pb::UserConsentTypes::ArcPlayTermsOfServiceConsent; |
| using sync_pb::UserConsentTypes; |
| using sync_pb::UserConsentSpecifics; |
| using sync_pb::UserEventSpecifics; |
| |
| namespace consent_auditor { |
| |
| namespace { |
| |
| const char kLocalConsentDescriptionKey[] = "description"; |
| const char kLocalConsentConfirmationKey[] = "confirmation"; |
| const char kLocalConsentVersionKey[] = "version"; |
| const char kLocalConsentLocaleKey[] = "locale"; |
| |
| bool IsSeparateConsentTypeEnabled() { |
| return base::FeatureList::IsEnabled(switches::kSyncUserConsentSeparateType); |
| } |
| |
| UserEventSpecifics::UserConsent::Feature FeatureToUserEventProtoEnum( |
| consent_auditor::Feature feature) { |
| switch (feature) { |
| case consent_auditor::Feature::CHROME_SYNC: |
| return UserEventSpecifics::UserConsent::CHROME_SYNC; |
| case consent_auditor::Feature::PLAY_STORE: |
| return UserEventSpecifics::UserConsent::PLAY_STORE; |
| case consent_auditor::Feature::BACKUP_AND_RESTORE: |
| return UserEventSpecifics::UserConsent::BACKUP_AND_RESTORE; |
| case consent_auditor::Feature::GOOGLE_LOCATION_SERVICE: |
| return UserEventSpecifics::UserConsent::GOOGLE_LOCATION_SERVICE; |
| case consent_auditor::Feature::CHROME_UNIFIED_CONSENT: |
| return UserEventSpecifics::UserConsent::CHROME_UNIFIED_CONSENT; |
| case consent_auditor::Feature::ASSISTANT_ACTIVITY_CONTROL: |
| return UserEventSpecifics::UserConsent::ASSISTANT_ACTIVITY_CONTROL; |
| } |
| NOTREACHED(); |
| return UserEventSpecifics::UserConsent::FEATURE_UNSPECIFIED; |
| } |
| |
| UserConsentTypes::ConsentStatus StatusToProtoEnum( |
| consent_auditor::ConsentStatus status) { |
| switch (status) { |
| case consent_auditor::ConsentStatus::NOT_GIVEN: |
| return UserConsentTypes::NOT_GIVEN; |
| case consent_auditor::ConsentStatus::GIVEN: |
| return UserConsentTypes::GIVEN; |
| } |
| NOTREACHED(); |
| return UserConsentTypes::CONSENT_STATUS_UNSPECIFIED; |
| } |
| |
| ConsentStatus ConvertConsentStatus( |
| UserConsentTypes::ConsentStatus consent_status) { |
| DCHECK_NE(consent_status, |
| UserConsentTypes::ConsentStatus:: |
| UserConsentTypes_ConsentStatus_CONSENT_STATUS_UNSPECIFIED); |
| |
| if (consent_status == |
| UserConsentTypes::ConsentStatus::UserConsentTypes_ConsentStatus_GIVEN) { |
| return ConsentStatus::GIVEN; |
| } |
| return ConsentStatus::NOT_GIVEN; |
| } |
| |
| std::unique_ptr<sync_pb::UserConsentSpecifics> CreateUserConsentSpecifics( |
| const std::string& account_id, |
| const std::string& locale, |
| base::Clock* clock) { |
| std::unique_ptr<sync_pb::UserConsentSpecifics> specifics = |
| std::make_unique<sync_pb::UserConsentSpecifics>(); |
| specifics->set_account_id(account_id); |
| specifics->set_client_consent_time_usec( |
| clock->Now().since_origin().InMicroseconds()); |
| specifics->set_locale(locale); |
| |
| return specifics; |
| } |
| |
| } // namespace |
| |
| ConsentAuditorImpl::ConsentAuditorImpl( |
| PrefService* pref_service, |
| std::unique_ptr<syncer::ConsentSyncBridge> consent_sync_bridge, |
| syncer::UserEventService* user_event_service, |
| const std::string& app_version, |
| const std::string& app_locale, |
| base::Clock* clock) |
| : pref_service_(pref_service), |
| consent_sync_bridge_(std::move(consent_sync_bridge)), |
| user_event_service_(user_event_service), |
| app_version_(app_version), |
| app_locale_(app_locale), |
| clock_(clock) { |
| if (IsSeparateConsentTypeEnabled()) { |
| DCHECK(consent_sync_bridge_ && !user_event_service_); |
| } else { |
| DCHECK(user_event_service_ && !consent_sync_bridge_); |
| } |
| DCHECK(pref_service_); |
| } |
| |
| ConsentAuditorImpl::~ConsentAuditorImpl() {} |
| |
| void ConsentAuditorImpl::Shutdown() { |
| user_event_service_ = nullptr; |
| } |
| |
| // static |
| void ConsentAuditorImpl::RegisterProfilePrefs(PrefRegistrySimple* registry) { |
| registry->RegisterDictionaryPref(prefs::kLocalConsentsDictionary); |
| } |
| |
| void ConsentAuditorImpl::RecordGaiaConsent( |
| const std::string& account_id, |
| Feature feature, |
| const std::vector<int>& description_grd_ids, |
| int confirmation_grd_id, |
| ConsentStatus status) { |
| DCHECK(!account_id.empty()) << "No signed-in account specified."; |
| |
| if (!base::FeatureList::IsEnabled(switches::kSyncUserConsentEvents)) |
| return; |
| |
| DCHECK_LE(feature, consent_auditor::Feature::FEATURE_LAST); |
| |
| switch (status) { |
| case ConsentStatus::GIVEN: |
| UMA_HISTOGRAM_ENUMERATION( |
| "Privacy.ConsentAuditor.ConsentGiven.Feature", feature, |
| static_cast<int>(consent_auditor::Feature::FEATURE_LAST) + 1); |
| break; |
| case ConsentStatus::NOT_GIVEN: |
| UMA_HISTOGRAM_ENUMERATION( |
| "Privacy.ConsentAuditor.ConsentNotGiven.Feature", feature, |
| static_cast<int>(consent_auditor::Feature::FEATURE_LAST) + 1); |
| break; |
| } |
| |
| DCHECK(!IsSeparateConsentTypeEnabled()); |
| // TODO(msramek): Pass in the actual account id. |
| std::unique_ptr<sync_pb::UserEventSpecifics> specifics = |
| ConstructUserEventSpecifics(account_id, feature, description_grd_ids, |
| confirmation_grd_id, status); |
| user_event_service_->RecordUserEvent(std::move(specifics)); |
| } |
| |
| std::unique_ptr<sync_pb::UserEventSpecifics> |
| ConsentAuditorImpl::ConstructUserEventSpecifics( |
| const std::string& account_id, |
| Feature feature, |
| const std::vector<int>& description_grd_ids, |
| int confirmation_grd_id, |
| ConsentStatus status) { |
| DCHECK(!IsSeparateConsentTypeEnabled()); |
| |
| auto specifics = std::make_unique<sync_pb::UserEventSpecifics>(); |
| specifics->set_event_time_usec(clock_->Now().since_origin().InMicroseconds()); |
| auto* consent = specifics->mutable_user_consent(); |
| consent->set_account_id(account_id); |
| consent->set_feature(FeatureToUserEventProtoEnum(feature)); |
| for (int id : description_grd_ids) { |
| consent->add_description_grd_ids(id); |
| } |
| consent->set_confirmation_grd_id(confirmation_grd_id); |
| consent->set_locale(app_locale_); |
| consent->set_status(StatusToProtoEnum(status)); |
| return specifics; |
| } |
| |
| void ConsentAuditorImpl::RecordArcPlayConsent( |
| const std::string& account_id, |
| const ArcPlayTermsOfServiceConsent& consent) { |
| if (IsSeparateConsentTypeEnabled()) { |
| std::unique_ptr<sync_pb::UserConsentSpecifics> specifics = |
| CreateUserConsentSpecifics(account_id, app_locale_, clock_); |
| |
| sync_pb::UserConsentTypes::ArcPlayTermsOfServiceConsent* arc_play_consent = |
| specifics->mutable_arc_play_terms_of_service_consent(); |
| arc_play_consent->CopyFrom(consent); |
| consent_sync_bridge_->RecordConsent(std::move(specifics)); |
| } else { |
| std::vector<int> description_grd_ids; |
| if (consent.consent_flow() == |
| ArcPlayTermsOfServiceConsent::SETTING_CHANGE) { |
| for (int grd_id : consent.description_grd_ids()) { |
| description_grd_ids.push_back(grd_id); |
| } |
| } else { |
| description_grd_ids.push_back( |
| consent.play_terms_of_service_text_length()); |
| |
| // TODO(markusheintz): The code below is a copy from the ARC code base. |
| // This will go away when the consent proto is set on the user consent |
| // specifics proto. |
| const std::string& hash_str = consent.play_terms_of_service_hash(); |
| DCHECK_EQ(base::kSHA1Length, hash_str.size()); |
| const uint8_t* hash = reinterpret_cast<const uint8_t*>(hash_str.data()); |
| for (size_t i = 0; i < base::kSHA1Length; i += 4) { |
| uint32_t acc = |
| hash[i] << 24 | hash[i + 1] << 16 | hash[i + 2] << 8 | hash[i + 3]; |
| description_grd_ids.push_back(static_cast<int>(acc)); |
| } |
| } |
| |
| RecordGaiaConsent(account_id, Feature::PLAY_STORE, description_grd_ids, |
| consent.confirmation_grd_id(), |
| ConvertConsentStatus(consent.status())); |
| } |
| } |
| |
| void ConsentAuditorImpl::RecordArcGoogleLocationServiceConsent( |
| const std::string& account_id, |
| const UserConsentTypes::ArcGoogleLocationServiceConsent& consent) { |
| if (IsSeparateConsentTypeEnabled()) { |
| std::unique_ptr<sync_pb::UserConsentSpecifics> specifics = |
| CreateUserConsentSpecifics(account_id, app_locale_, clock_); |
| |
| sync_pb::UserConsentTypes::ArcGoogleLocationServiceConsent* |
| arc_google_location_service_consent = |
| specifics->mutable_arc_location_service_consent(); |
| arc_google_location_service_consent->CopyFrom(consent); |
| consent_sync_bridge_->RecordConsent(std::move(specifics)); |
| } else { |
| std::vector<int> description_grd_ids(consent.description_grd_ids().begin(), |
| consent.description_grd_ids().end()); |
| |
| RecordGaiaConsent(account_id, Feature::GOOGLE_LOCATION_SERVICE, |
| description_grd_ids, consent.confirmation_grd_id(), |
| ConvertConsentStatus(consent.status())); |
| } |
| } |
| |
| void ConsentAuditorImpl::RecordArcBackupAndRestoreConsent( |
| const std::string& account_id, |
| const UserConsentTypes::ArcBackupAndRestoreConsent& consent) { |
| if (IsSeparateConsentTypeEnabled()) { |
| std::unique_ptr<sync_pb::UserConsentSpecifics> specifics = |
| CreateUserConsentSpecifics(account_id, app_locale_, clock_); |
| |
| sync_pb::UserConsentTypes::ArcBackupAndRestoreConsent* |
| arc_backup_and_restore_consent = |
| specifics->mutable_arc_backup_and_restore_consent(); |
| arc_backup_and_restore_consent->CopyFrom(consent); |
| consent_sync_bridge_->RecordConsent(std::move(specifics)); |
| } else { |
| std::vector<int> description_grd_ids(consent.description_grd_ids().begin(), |
| consent.description_grd_ids().end()); |
| |
| RecordGaiaConsent(account_id, Feature::BACKUP_AND_RESTORE, |
| description_grd_ids, consent.confirmation_grd_id(), |
| ConvertConsentStatus(consent.status())); |
| } |
| } |
| |
| void ConsentAuditorImpl::RecordSyncConsent( |
| const std::string& account_id, |
| const UserConsentTypes::SyncConsent& consent) { |
| if (IsSeparateConsentTypeEnabled()) { |
| std::unique_ptr<sync_pb::UserConsentSpecifics> specifics = |
| CreateUserConsentSpecifics(account_id, app_locale_, clock_); |
| |
| sync_pb::UserConsentTypes::SyncConsent* sync_consent = |
| specifics->mutable_sync_consent(); |
| sync_consent->CopyFrom(consent); |
| consent_sync_bridge_->RecordConsent(std::move(specifics)); |
| } else { |
| std::vector<int> description_grd_ids(consent.description_grd_ids().begin(), |
| consent.description_grd_ids().end()); |
| |
| RecordGaiaConsent(account_id, Feature::CHROME_SYNC, description_grd_ids, |
| consent.confirmation_grd_id(), |
| ConvertConsentStatus(consent.status())); |
| } |
| } |
| |
| void ConsentAuditorImpl::RecordUnifiedConsent( |
| const std::string& account_id, |
| const sync_pb::UserConsentTypes::UnifiedConsent& consent) { |
| if (IsSeparateConsentTypeEnabled()) { |
| std::unique_ptr<sync_pb::UserConsentSpecifics> specifics = |
| CreateUserConsentSpecifics(account_id, app_locale_, clock_); |
| |
| sync_pb::UserConsentTypes::UnifiedConsent* unified_consent = |
| specifics->mutable_unified_consent(); |
| unified_consent->CopyFrom(consent); |
| consent_sync_bridge_->RecordConsent(std::move(specifics)); |
| } else { |
| std::vector<int> description_grd_ids(consent.description_grd_ids().begin(), |
| consent.description_grd_ids().end()); |
| |
| RecordGaiaConsent(account_id, Feature::CHROME_UNIFIED_CONSENT, |
| description_grd_ids, consent.confirmation_grd_id(), |
| ConvertConsentStatus(consent.status())); |
| } |
| } |
| |
| void ConsentAuditorImpl::RecordAssistantActivityControlConsent( |
| const std::string& account_id, |
| const sync_pb::UserConsentTypes::AssistantActivityControlConsent& consent) { |
| // TODO(markusheintz): Turn this into a DCHECK once the fallback is not |
| // needed. |
| if (IsSeparateConsentTypeEnabled()) { |
| std::unique_ptr<sync_pb::UserConsentSpecifics> specifics = |
| CreateUserConsentSpecifics(account_id, app_locale_, clock_); |
| sync_pb::UserConsentTypes::AssistantActivityControlConsent* |
| assistant_consent = |
| specifics->mutable_assistant_activity_control_consent(); |
| assistant_consent->CopyFrom(consent); |
| |
| consent_sync_bridge_->RecordConsent(std::move(specifics)); |
| } else { |
| // TODO(markusheintz): This code was only added in case we have to fallback |
| // to the deprecated way of recording user consents via the |
| // UserEventSpecifics. Remove if not needed. |
| std::vector<int> description_grd_ids; |
| const std::string& ui_audit_key = consent.ui_audit_key(); |
| description_grd_ids.push_back(ui_audit_key.length()); |
| for (size_t i = 0; i < ui_audit_key.length(); i++) { |
| description_grd_ids.push_back(ui_audit_key[i]); |
| } |
| std::unique_ptr<sync_pb::UserEventSpecifics> user_event_specifics = |
| ConstructUserEventSpecifics(account_id, |
| Feature::ASSISTANT_ACTIVITY_CONTROL, |
| description_grd_ids, |
| 0, // No confirmation grd id recorded. |
| ConvertConsentStatus(consent.status())); |
| user_event_service_->RecordUserEvent(std::move(user_event_specifics)); |
| } |
| } |
| |
| void ConsentAuditorImpl::RecordLocalConsent( |
| const std::string& feature, |
| const std::string& description_text, |
| const std::string& confirmation_text) { |
| DictionaryPrefUpdate consents_update(pref_service_, |
| prefs::kLocalConsentsDictionary); |
| base::DictionaryValue* consents = consents_update.Get(); |
| DCHECK(consents); |
| |
| base::DictionaryValue record; |
| record.SetKey(kLocalConsentDescriptionKey, base::Value(description_text)); |
| record.SetKey(kLocalConsentConfirmationKey, base::Value(confirmation_text)); |
| record.SetKey(kLocalConsentVersionKey, base::Value(app_version_)); |
| record.SetKey(kLocalConsentLocaleKey, base::Value(app_locale_)); |
| |
| consents->SetKey(feature, std::move(record)); |
| } |
| |
| base::WeakPtr<syncer::ModelTypeControllerDelegate> |
| ConsentAuditorImpl::GetControllerDelegate() { |
| if (consent_sync_bridge_) { |
| return consent_sync_bridge_->GetControllerDelegate(); |
| } |
| return base::WeakPtr<syncer::ModelTypeControllerDelegate>(); |
| } |
| |
| } // namespace consent_auditor |
