arc: Use location service consent.

chrome/browser/chromeos/arc/arc_settings_service.cc

 // 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 "chrome/browser/chromeos/arc/arc_settings_service.h"
 
 #include <string>
 
 #include "base/gtest_prod_util.h"
 #include "base/json/json_writer.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
+#include "chrome/browser/chromeos/arc/arc_auth_service.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "chromeos/settings/timezone_settings.h"
 #include "components/arc/intent_helper/font_size_util.h"
 #include "components/prefs/pref_change_registrar.h"
 #include "components/prefs/pref_service.h"
 #include "components/proxy_config/proxy_config_dictionary.h"
 #include "components/proxy_config/proxy_config_pref_names.h"
@@ skipping 33 matching lines @@
 }
 
 }  // namespace
 
 namespace arc {
 
 // Listens to changes for select Chrome settings (prefs) that Android cares
 // about and sends the new values to Android to keep the state in sync.
 class ArcSettingsServiceImpl
     : public chromeos::system::TimezoneSettings::Observer,
-      public device::BluetoothAdapter::Observer {
+      public device::BluetoothAdapter::Observer,
+      public ArcAuthService::Observer {
  public:
   explicit ArcSettingsServiceImpl(ArcBridgeService* arc_bridge_service);
   ~ArcSettingsServiceImpl() override;
 
   // Called when a Chrome pref we have registered an observer for has changed.
   // Obtains the new pref value and sends it to Android.
   void OnPrefChanged(const std::string& pref_name) const;
 
-  // TimezoneSettings::Observer
+  // TimezoneSettings::Observer:
   void TimezoneChanged(const icu::TimeZone& timezone) override;
 
-  // BluetoothAdapter::Observer
+  // BluetoothAdapter::Observer:
   void AdapterPoweredChanged(device::BluetoothAdapter* adapter,
                              bool powered) override;
 
+  // ArcAuthService::Observer:
+  void OnInitialStart() override;
+
  private:
   // Registers to observe changes for Chrome settings we care about.
   void StartObservingSettingsChanges();
 
   // Stops listening for Chrome settings changes.
   void StopObservingSettingsChanges();
 
-  // Retrives Chrome's state for the settings and send it to Android.
-  void SyncAllPrefs() const;
+  // Retrieves Chrome's state for the settings that need to be synced on each
+  // Android boot and send it to Android.
+  void SyncRuntimeSettings() const;
+  // Send settings that need to be synced only on Android first start to
+  // Android.
+  void SyncInitialSettings() const;
   void SyncFontSize() const;
   void SyncLocale() const;
   void SyncProxySettings() const;
   void SyncReportingConsent() const;
   void SyncSpokenFeedbackEnabled() const;
   void SyncTimeZone() const;
   void SyncUse24HourClock() const;
   void SyncBackupEnabled() const;
+  void SyncLocationServiceEnabled() const;
 
   void OnBluetoothAdapterInitialized(
       scoped_refptr<device::BluetoothAdapter> adapter);
 
   // Registers to listen to a particular perf.
   void AddPrefToObserve(const std::string& pref_name);
 
   // Returns the integer value of the pref.  pref_name must exist.
   int GetIntegerPref(const std::string& pref_name) const;
 
+  // Sends boolean pref broadcast to the delegate.
+  void SendBoolPrefSettingsBroadcast(const std::string& pref_name,
+                                     const std::string& action) const;
+
   // Sends a broadcast to the delegate.
   void SendSettingsBroadcast(const std::string& action,
                              const base::DictionaryValue& extras) const;
 
   // Manages pref observation registration.
   PrefChangeRegistrar registrar_;
 
   std::unique_ptr<chromeos::CrosSettings::ObserverSubscription>
       reporting_consent_subscription_;
   ArcBridgeService* const arc_bridge_service_;
 
   scoped_refptr<device::BluetoothAdapter> bluetooth_adapter_;
 
   // WeakPtrFactory to use for callback for getting the bluetooth adapter.
   base::WeakPtrFactory<ArcSettingsServiceImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ArcSettingsServiceImpl);
 };
 
 ArcSettingsServiceImpl::ArcSettingsServiceImpl(
     ArcBridgeService* arc_bridge_service)
     : arc_bridge_service_(arc_bridge_service), weak_factory_(this) {
   StartObservingSettingsChanges();
-  SyncAllPrefs();
+  SyncRuntimeSettings();
+  DCHECK(ArcAuthService::Get());
+  ArcAuthService::Get()->AddObserver(this);
 }
 
 ArcSettingsServiceImpl::~ArcSettingsServiceImpl() {
   StopObservingSettingsChanges();
 
-  if (bluetooth_adapter_) {
+  ArcAuthService* arc_auth_service = ArcAuthService::Get();
+  if (arc_auth_service)
+    arc_auth_service->RemoveObserver(this);
+
+  if (bluetooth_adapter_)
     bluetooth_adapter_->RemoveObserver(this);
-  }
 }
 
 void ArcSettingsServiceImpl::StartObservingSettingsChanges() {
   Profile* profile = ProfileManager::GetActiveUserProfile();
   registrar_.Init(profile->GetPrefs());
 
   AddPrefToObserve(prefs::kWebKitDefaultFixedFontSize);
   AddPrefToObserve(prefs::kWebKitDefaultFontSize);
   AddPrefToObserve(prefs::kWebKitMinimumFontSize);
   AddPrefToObserve(prefs::kAccessibilitySpokenFeedbackEnabled);
@@ skipping 17 matching lines @@
 
 void ArcSettingsServiceImpl::OnBluetoothAdapterInitialized(
     scoped_refptr<device::BluetoothAdapter> adapter) {
   DCHECK(adapter);
   bluetooth_adapter_ = adapter;
   bluetooth_adapter_->AddObserver(this);
 
   AdapterPoweredChanged(adapter.get(), adapter->IsPowered());
 }
 
-void ArcSettingsServiceImpl::SyncAllPrefs() const {
+void ArcSettingsServiceImpl::OnInitialStart() {
+  SyncInitialSettings();
+}
+
+void ArcSettingsServiceImpl::SyncRuntimeSettings() const {
   SyncFontSize();
   SyncLocale();
   SyncProxySettings();
   SyncReportingConsent();
   SyncSpokenFeedbackEnabled();
   SyncTimeZone();
   SyncUse24HourClock();
 }
 
+void ArcSettingsServiceImpl::SyncInitialSettings() const {
+  SyncBackupEnabled();
+  SyncLocationServiceEnabled();
+}
+
 void ArcSettingsServiceImpl::StopObservingSettingsChanges() {
   registrar_.RemoveAll();
   reporting_consent_subscription_.reset();
 
   TimezoneSettings::GetInstance()->RemoveObserver(this);
 }
 
 void ArcSettingsServiceImpl::AddPrefToObserve(const std::string& pref_name) {
   registrar_.Add(pref_name, base::Bind(&ArcSettingsServiceImpl::OnPrefChanged,
                                        base::Unretained(this)));
@@ skipping 12 matching lines @@
   if (pref_name == prefs::kAccessibilitySpokenFeedbackEnabled) {
     SyncSpokenFeedbackEnabled();
   } else if (pref_name == prefs::kWebKitDefaultFixedFontSize ||
              pref_name == prefs::kWebKitDefaultFontSize ||
              pref_name == prefs::kWebKitMinimumFontSize) {
     SyncFontSize();
   } else if (pref_name == prefs::kUse24HourClock) {
     SyncUse24HourClock();
   } else if (pref_name == proxy_config::prefs::kProxy) {
     SyncProxySettings();
-  } else if (pref_name == prefs::kArcBackupRestoreEnabled) {
-    SyncBackupEnabled();

[Sergey Poromov, 2016/08/02 15:20:41]

Looks like because of removing these lines, backup pref won't be synced when
changed because of policy change.
Please, revert these lines.

[khmel, 2016/08/02 16:22:44]

This code does not make sense. kArcBackupRestoreEnabled is local pref and can be
changed during Arc OptIn flow (and it is true by default). Even if it has been
changed in OptIn Arc is not started at this moment and IPC message is not
delivered.

Please see SyncInitialSettings for backup fix.

[Sergey Poromov, 2016/08/02 17:43:49]

What if the pref changes after OptIn, because of policy change? How should we
transmit the change to Android side?

   } else {
     LOG(ERROR) << "Unknown pref changed.";
   }
 }
 
 void ArcSettingsServiceImpl::TimezoneChanged(const icu::TimeZone& timezone) {
   SyncTimeZone();
 }
 
 int ArcSettingsServiceImpl::GetIntegerPref(const std::string& pref_name) const {
@@ skipping 13 matching lines @@
 
   double android_scale = ConvertFontSizeChromeToAndroid(
       default_size, default_fixed_size, minimum_size);
 
   base::DictionaryValue extras;
   extras.SetDouble("scale", android_scale);
   SendSettingsBroadcast("org.chromium.arc.intent_helper.SET_FONT_SCALE",
                         extras);
 }
 
-void ArcSettingsServiceImpl::SyncSpokenFeedbackEnabled() const {
-  const PrefService::Preference* pref = registrar_.prefs()->FindPreference(
-      prefs::kAccessibilitySpokenFeedbackEnabled);
+void ArcSettingsServiceImpl::SendBoolPrefSettingsBroadcast(
+    const std::string& pref_name,
+    const std::string& action) const {
+  const PrefService::Preference* pref =
+      registrar_.prefs()->FindPreference(pref_name);
   DCHECK(pref);
   bool enabled = false;
   bool value_exists = pref->GetValue()->GetAsBoolean(&enabled);
   DCHECK(value_exists);
   base::DictionaryValue extras;
   extras.SetBoolean("enabled", enabled);
-  SendSettingsBroadcast(
-      "org.chromium.arc.intent_helper.SET_SPOKEN_FEEDBACK_ENABLED", extras);
+  extras.SetBoolean("managed", !pref->IsUserModifiable());
+  SendSettingsBroadcast(action, extras);
+}
+
+void ArcSettingsServiceImpl::SyncSpokenFeedbackEnabled() const {
+  SendBoolPrefSettingsBroadcast(
+      prefs::kAccessibilitySpokenFeedbackEnabled,
+      "org.chromium.arc.intent_helper.SET_SPOKEN_FEEDBACK_ENABLED");
 }
 
 void ArcSettingsServiceImpl::SyncLocale() const {
   const PrefService::Preference* pref =
       registrar_.prefs()->FindPreference(prefs::kApplicationLocale);
   DCHECK(pref);
   std::string locale;
   bool value_exists = pref->GetValue()->GetAsString(&locale);
   DCHECK(value_exists);
   base::DictionaryValue extras;
@@ skipping 84 matching lines @@
     }
     default:
       LOG(ERROR) << "Incorrect proxy mode.";
       return;
   }
 
   SendSettingsBroadcast("org.chromium.arc.intent_helper.SET_PROXY", extras);
 }
 
 void ArcSettingsServiceImpl::SyncBackupEnabled() const {
-  const PrefService::Preference* const pref =
-      registrar_.prefs()->FindPreference(prefs::kArcBackupRestoreEnabled);
-  DCHECK(pref);
-  bool enabled = false;
-  bool value_exists = pref->GetValue()->GetAsBoolean(&enabled);
-  DCHECK(value_exists);
-  base::DictionaryValue extras;
-  extras.SetBoolean("enabled", enabled);
-  extras.SetBoolean("managed", !pref->IsUserModifiable());
-  SendSettingsBroadcast("org.chromium.arc.intent_helper.SET_BACKUP_ENABLED",
-                        extras);
+  SendBoolPrefSettingsBroadcast(
+      prefs::kArcBackupRestoreEnabled,
+      "org.chromium.arc.intent_helper.SET_BACKUP_ENABLED");
+}
+
+void ArcSettingsServiceImpl::SyncLocationServiceEnabled() const {
+  SendBoolPrefSettingsBroadcast(
+      prefs::kArcLocationServiceEnabled,
+      "org.chromium.arc.intent_helper.SET_LOCATION_SERVICE_ENABLED");
 }
 
 void ArcSettingsServiceImpl::SendSettingsBroadcast(
     const std::string& action,
     const base::DictionaryValue& extras) const {
   if (!arc_bridge_service_->intent_helper()->instance()) {
     LOG(ERROR) << "IntentHelper instance is not ready.";
     return;
   }
 
@@ skipping 19 matching lines @@
 
 void ArcSettingsService::OnInstanceReady() {
   impl_.reset(new ArcSettingsServiceImpl(arc_bridge_service()));
 }
 
 void ArcSettingsService::OnInstanceClosed() {
   impl_.reset();
 }
 
 }  // namespace arc