Do not sync ARC opt-in preference

chrome/browser/chromeos/arc/arc_auth_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_auth_service.h"
 
 #include <utility>
 
 #include "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/wm_shell.h"
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/strings/string16.h"
 #include "chrome/browser/chromeos/arc/arc_android_management_checker.h"
 #include "chrome/browser/chromeos/arc/arc_auth_context.h"
 #include "chrome/browser/chromeos/arc/arc_auth_notification.h"
 #include "chrome/browser/chromeos/arc/arc_optin_uma.h"
 #include "chrome/browser/chromeos/arc/arc_support_host.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/policy/profile_policy_connector.h"
 #include "chrome/browser/policy/profile_policy_connector_factory.h"
-#include "chrome/browser/prefs/pref_service_syncable_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_launcher.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_utils.h"
 #include "chrome/browser/ui/ash/multi_user/multi_user_util.h"
 #include "chrome/browser/ui/extensions/app_launch_params.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/cryptohome/cryptohome_parameters.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/policy/core/browser/browser_policy_connector.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
-#include "components/syncable_prefs/pref_service_syncable.h"
 #include "components/user_manager/user.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/app_window/app_window_registry.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace arc {
 
 namespace {
@@ skipping 338 matching lines @@
 
   // TODO(khmel): Move this to IsAllowedForProfile.
   if (IsArcDisabledForEnterprise() && IsAccountManaged(profile)) {
     VLOG(2) << "Enterprise users are not supported in ARC.";
     return;
   }
 
   profile_ = profile;
   SetState(State::STOPPED);
 
-  PrefServiceSyncableFromProfile(profile_)->AddSyncedPrefObserver(
-      prefs::kArcEnabled, this);
-
   context_.reset(new ArcAuthContext(this, profile_));
 
   // In case UI is disabled we assume that ARC is opted-in.
   if (IsOptInVerificationDisabled()) {
     auth_code_.clear();
     StartArc();
     return;
   }
 
   if (!g_disable_ui_for_testing ||
       g_enable_check_android_management_for_testing) {
     ArcAndroidManagementChecker::StartClient();
   }
   pref_change_registrar_.Init(profile_->GetPrefs());
   pref_change_registrar_.Add(
       prefs::kArcEnabled, base::Bind(&ArcAuthService::OnOptInPreferenceChanged,
                                      weak_ptr_factory_.GetWeakPtr()));
   if (profile_->GetPrefs()->GetBoolean(prefs::kArcEnabled)) {
     OnOptInPreferenceChanged();
   } else {
     UpdateEnabledStateUMA(false);
-    PrefServiceSyncableFromProfile(profile_)->AddObserver(this);
-    OnIsSyncingChanged();
-  }
-}
-
-void ArcAuthService::OnIsSyncingChanged() {
-  syncable_prefs::PrefServiceSyncable* const pref_service_syncable =
-      PrefServiceSyncableFromProfile(profile_);
-  if (!pref_service_syncable->IsSyncing())
-    return;
-
-  pref_service_syncable->RemoveObserver(this);
-
-  if (IsArcEnabled())
-    OnOptInPreferenceChanged();
-
-  if (!g_disable_ui_for_testing && profile_->IsNewProfile() &&
-      !profile_->GetPrefs()->HasPrefPath(prefs::kArcEnabled)) {
-    ArcAuthNotification::Show(profile_);
   }
 }
 
 void ArcAuthService::Shutdown() {
   ShutdownBridgeAndCloseUI();
-  if (profile_) {
-    syncable_prefs::PrefServiceSyncable* pref_service_syncable =
-        PrefServiceSyncableFromProfile(profile_);
-    pref_service_syncable->RemoveObserver(this);
-    pref_service_syncable->RemoveSyncedPrefObserver(prefs::kArcEnabled, this);
-  }
   pref_change_registrar_.RemoveAll();
   context_.reset();
   profile_ = nullptr;
   SetState(State::NOT_INITIALIZED);
 }
 
 void ArcAuthService::ShowUI(UIPage page, const base::string16& status) {
   if (g_disable_ui_for_testing || IsOptInVerificationDisabled())
     return;
 
@@ skipping 16 matching lines @@
       profile_, extension, NEW_WINDOW, extensions::SOURCE_CHROME_INTERNAL));
 }
 
 void ArcAuthService::OnContextReady() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   DCHECK(!initial_opt_in_);
   CheckAndroidManagement(false);
 }
 
-void ArcAuthService::OnSyncedPrefChanged(const std::string& path,
-                                         bool from_sync) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-
-  // Update UMA only for local changes
-  if (!from_sync) {
-    const bool arc_enabled =
-        profile_->GetPrefs()->GetBoolean(prefs::kArcEnabled);
-    UpdateOptInActionUMA(arc_enabled ? OptInActionType::OPTED_IN
-                                     : OptInActionType::OPTED_OUT);
-
-    if (!disable_arc_from_ui_ && !arc_enabled && !IsArcManaged()) {
-      ash::ShelfDelegate* shelf_delegate = GetShelfDelegate();
-      if (shelf_delegate)
-        shelf_delegate->UnpinAppWithID(ArcSupportHost::kHostAppId);
-    }
-  }
-}
-
 void ArcAuthService::StopArc() {
   if (state_ != State::STOPPED) {
     UpdateEnabledStateUMA(false);
     profile_->GetPrefs()->SetBoolean(prefs::kArcSignedIn, false);
   }
   ShutdownBridgeAndCloseUI();
 }
 
 void ArcAuthService::OnOptInPreferenceChanged() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(profile_);
 
   const bool arc_enabled = IsArcEnabled();
   FOR_EACH_OBSERVER(Observer, observer_list_, OnOptInEnabled(arc_enabled));
 
+  UpdateOptInActionUMA(arc_enabled ? OptInActionType::OPTED_IN

[khmel, 2016/08/03 14:28:32]

Now this statistics is incorrect for managed pref. This UMA for user's action.
When admin manages this feature we don't update it. That means arc.enabled can
be synced even if it is declared local. We have to check all cases, including
when managed state is changed during Arc start.

+                                   : OptInActionType::OPTED_OUT);
+
+  if (!disable_arc_from_ui_ && !arc_enabled && !IsArcManaged()) {
+    ash::ShelfDelegate* shelf_delegate = GetShelfDelegate();
+    if (shelf_delegate)
+      shelf_delegate->UnpinAppWithID(ArcSupportHost::kHostAppId);
+  }
+
   if (!arc_enabled) {
     StopArc();
     return;
   }
 
   if (state_ == State::ACTIVE)
     return;
   CloseUI();
   auth_code_.clear();
 
@@ skipping 271 matching lines @@
       return os << kStateFetchingCode;
     case ArcAuthService::State::ACTIVE:
       return os << kStateActive;
     default:
       NOTREACHED();
       return os;
   }
 }
 
 }  // namespace arc