Setup Chromad user policy plumbing

chrome/browser/ui/webui/policy_ui_handler.cc

 // Copyright (c) 2012 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/ui/webui/policy_ui_handler.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 41 matching lines @@
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/time_format.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/browser_process_platform_part.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/policy/device_active_directory_policy_manager.h"
 #include "chrome/browser/chromeos/policy/device_cloud_policy_store_chromeos.h"
 #include "chrome/browser/chromeos/policy/device_local_account_policy_service.h"
+#include "chrome/browser/chromeos/policy/user_active_directory_policy_manager.h"
 #include "chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.h"
 #include "chrome/browser/chromeos/policy/user_cloud_policy_manager_factory_chromeos.h"
 #include "chrome/browser/chromeos/settings/install_attributes.h"
 #include "components/user_manager/user_manager.h"
 #else
 #include "chrome/browser/policy/cloud/user_cloud_policy_manager_factory.h"
 #include "components/policy/core/common/cloud/user_cloud_policy_manager.h"
 #endif
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
@@ skipping 171 matching lines @@
  protected:
   // Policy status is read from the CloudPolicyClient, CloudPolicyStore and
   // CloudPolicyRefreshScheduler hosted by this |core_|.
   policy::CloudPolicyCore* core_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CloudPolicyCoreStatusProvider);
 };
 
 // A cloud policy status provider for user policy.
-class UserPolicyStatusProvider : public CloudPolicyCoreStatusProvider {
+class UserCloudPolicyStatusProvider : public CloudPolicyCoreStatusProvider {
  public:
-  explicit UserPolicyStatusProvider(policy::CloudPolicyCore* core);
-  ~UserPolicyStatusProvider() override;
+  explicit UserCloudPolicyStatusProvider(policy::CloudPolicyCore* core);
+  ~UserCloudPolicyStatusProvider() override;
 
   // CloudPolicyCoreStatusProvider implementation.
   void GetStatus(base::DictionaryValue* dict) override;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(UserPolicyStatusProvider);
+  DISALLOW_COPY_AND_ASSIGN(UserCloudPolicyStatusProvider);
 };
 
 #if defined(OS_CHROMEOS)
 // A cloud policy status provider for device policy.
 class DevicePolicyStatusProvider : public CloudPolicyCoreStatusProvider {
  public:
   explicit DevicePolicyStatusProvider(
       policy::BrowserPolicyConnectorChromeOS* connector);
   ~DevicePolicyStatusProvider() override;
 
@@ skipping 28 matching lines @@
   void OnPolicyUpdated(const std::string& user_id) override;
   void OnDeviceLocalAccountsChanged() override;
 
  private:
   const std::string user_id_;
   policy::DeviceLocalAccountPolicyService* service_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceLocalAccountPolicyStatusProvider);
 };
 
-// Provides status for DeviceActiveDirectoryPolicyManager.
-class DeviceActiveDirectoryPolicyStatusProvider
+// Provides status for any Active Directory policy manager.

[emaxx, 2016/12/28 19:09:20]

nit: Add comment to explain explicitly that it's both for device and user
policy? Unless I misunderstood this.

[Thiemo Nagel, 2016/12/29 15:08:28]

Actually it's "either/or" not "both".  I've updated the comment to (hopefully)
make that more clear.  (Not visible here because I've moved the webui changes
out to a dependent CL: https://codereview.chromium.org/2608573002/.)

+class ActiveDirectoryPolicyStatusProvider
     : public PolicyStatusProvider,
       public policy::CloudPolicyStore::Observer {
  public:
-  explicit DeviceActiveDirectoryPolicyStatusProvider(
-      policy::DeviceActiveDirectoryPolicyManager* manager);
-  ~DeviceActiveDirectoryPolicyStatusProvider() override;
+  explicit ActiveDirectoryPolicyStatusProvider(policy::CloudPolicyStore* store);
+  ~ActiveDirectoryPolicyStatusProvider() override;
 
   // PolicyStatusProvider implementation.
   void GetStatus(base::DictionaryValue* dict) override;
 
   // policy::CloudPolicyStore::Observer implementation.
   void OnStoreLoaded(policy::CloudPolicyStore* store) override;
   void OnStoreError(policy::CloudPolicyStore* store) override;
 
  private:
   policy::CloudPolicyStore* store_;
 
-  DISALLOW_COPY_AND_ASSIGN(DeviceActiveDirectoryPolicyStatusProvider);
+  DISALLOW_COPY_AND_ASSIGN(ActiveDirectoryPolicyStatusProvider);
 };
 #endif
 
 PolicyStatusProvider::PolicyStatusProvider() {}
 
 PolicyStatusProvider::~PolicyStatusProvider() {}
 
 void PolicyStatusProvider::SetStatusChangeCallback(
     const base::Closure& callback) {
   callback_ = callback;
@@ skipping 21 matching lines @@
 void CloudPolicyCoreStatusProvider::OnStoreLoaded(
     policy::CloudPolicyStore* store) {
   NotifyStatusChange();
 }
 
 void CloudPolicyCoreStatusProvider::OnStoreError(
     policy::CloudPolicyStore* store) {
   NotifyStatusChange();
 }
 
-UserPolicyStatusProvider::UserPolicyStatusProvider(
-    policy::CloudPolicyCore* core) : CloudPolicyCoreStatusProvider(core) {
-}
+UserCloudPolicyStatusProvider::UserCloudPolicyStatusProvider(
+    policy::CloudPolicyCore* core)
+    : CloudPolicyCoreStatusProvider(core) {}
 
-UserPolicyStatusProvider::~UserPolicyStatusProvider() {
-}
+UserCloudPolicyStatusProvider::~UserCloudPolicyStatusProvider() {}
 
-void UserPolicyStatusProvider::GetStatus(base::DictionaryValue* dict) {
+void UserCloudPolicyStatusProvider::GetStatus(base::DictionaryValue* dict) {
   if (!core_->store()->is_managed())
     return;
   GetStatusFromCore(core_, dict);
   ExtractDomainFromUsername(dict);
 }
 
 #if defined(OS_CHROMEOS)
 DevicePolicyStatusProvider::DevicePolicyStatusProvider(
     policy::BrowserPolicyConnectorChromeOS* connector)
       : CloudPolicyCoreStatusProvider(
@@ skipping 43 matching lines @@
 void DeviceLocalAccountPolicyStatusProvider::OnPolicyUpdated(
     const std::string& user_id) {
   if (user_id == user_id_)
     NotifyStatusChange();
 }
 
 void DeviceLocalAccountPolicyStatusProvider::OnDeviceLocalAccountsChanged() {
   NotifyStatusChange();
 }
 
-DeviceActiveDirectoryPolicyStatusProvider::
-    DeviceActiveDirectoryPolicyStatusProvider(
-        policy::DeviceActiveDirectoryPolicyManager* manager)
-    : store_(manager->store()) {
+ActiveDirectoryPolicyStatusProvider::ActiveDirectoryPolicyStatusProvider(
+    policy::CloudPolicyStore* store)
+    : store_(store) {
   store_->AddObserver(this);
 }
 
-DeviceActiveDirectoryPolicyStatusProvider::
-    ~DeviceActiveDirectoryPolicyStatusProvider() {
+ActiveDirectoryPolicyStatusProvider::~ActiveDirectoryPolicyStatusProvider() {
   store_->RemoveObserver(this);
 }
 
 // TODO(tnagel): Provide more details and/or remove unused fields from UI.  See
 // https://crbug.com/664747.
-void DeviceActiveDirectoryPolicyStatusProvider::GetStatus(
+void ActiveDirectoryPolicyStatusProvider::GetStatus(
     base::DictionaryValue* dict) {
   base::string16 status =
       policy::FormatStoreStatus(store_->status(), store_->validation_status());
   dict->SetString("status", status);
 }
 
-void DeviceActiveDirectoryPolicyStatusProvider::OnStoreLoaded(
+void ActiveDirectoryPolicyStatusProvider::OnStoreLoaded(
     policy::CloudPolicyStore* store) {
   NotifyStatusChange();
 }
 
-void DeviceActiveDirectoryPolicyStatusProvider::OnStoreError(
+void ActiveDirectoryPolicyStatusProvider::OnStoreError(
     policy::CloudPolicyStore* store) {
   NotifyStatusChange();
 }
 
 #endif  // defined(OS_CHROMEOS)
 
 PolicyUIHandler::PolicyUIHandler()
     : weak_factory_(this) {
 }
 
@@ skipping 41 matching lines @@
   source->SetJsonPath("strings.js");
 }
 
 void PolicyUIHandler::RegisterMessages() {
 #if defined(OS_CHROMEOS)
   policy::BrowserPolicyConnectorChromeOS* connector =
       g_browser_process->platform_part()->browser_policy_connector_chromeos();
   if (connector->IsEnterpriseManaged()) {
     if (connector->GetDeviceActiveDirectoryPolicyManager()) {
       device_status_provider_ =
-          base::MakeUnique<DeviceActiveDirectoryPolicyStatusProvider>(
-              connector->GetDeviceActiveDirectoryPolicyManager());
+          base::MakeUnique<ActiveDirectoryPolicyStatusProvider>(
+              connector->GetDeviceActiveDirectoryPolicyManager()->store());
     } else {
       device_status_provider_ =
           base::MakeUnique<DevicePolicyStatusProvider>(connector);
     }
   }
 
   const user_manager::UserManager* user_manager =
       user_manager::UserManager::Get();
   if (user_manager->IsLoggedInAsPublicAccount()) {
     policy::DeviceLocalAccountPolicyService* local_account_service =
         connector->GetDeviceLocalAccountPolicyService();
     if (local_account_service) {
       user_status_provider_ =
           base::MakeUnique<DeviceLocalAccountPolicyStatusProvider>(
               user_manager->GetActiveUser()->GetAccountId().GetUserEmail(),
               local_account_service);
     }
   } else {
-    policy::UserCloudPolicyManagerChromeOS* user_cloud_policy_manager =
-        policy::UserCloudPolicyManagerFactoryChromeOS::GetForProfile(
-            Profile::FromWebUI(web_ui()));
-    if (user_cloud_policy_manager) {
-      user_status_provider_ =
-          base::MakeUnique<UserPolicyStatusProvider>(
-              user_cloud_policy_manager->core());
+    Profile* profile = Profile::FromWebUI(web_ui());
+    policy::UserCloudPolicyManagerChromeOS* user_cloud_policy =
+        policy::UserCloudPolicyManagerFactoryChromeOS::
+            GetCloudPolicyManagerForProfile(profile);
+    if (user_cloud_policy) {
+      user_status_provider_ = base::MakeUnique<UserCloudPolicyStatusProvider>(
+          user_cloud_policy->core());
+    } else {
+      policy::UserActiveDirectoryPolicyManager* active_directory_policy =
+          policy::UserCloudPolicyManagerFactoryChromeOS::
+              GetActiveDirectoryPolicyManagerForProfile(profile);
+      if (active_directory_policy) {

[emaxx, 2016/12/28 19:09:20]

Could we transform this into a more readable sequence of conditions like
if ...
else if ...
else if ...
?

[Thiemo Nagel, 2016/12/29 15:08:28]

Done.  (Also moved to separate CL.)

+        user_status_provider_ =
+            base::MakeUnique<ActiveDirectoryPolicyStatusProvider>(
+                active_directory_policy->store());
+      }
     }
   }
 #else
   policy::UserCloudPolicyManager* user_cloud_policy_manager =
       policy::UserCloudPolicyManagerFactory::GetForBrowserContext(
           web_ui()->GetWebContents()->GetBrowserContext());
   if (user_cloud_policy_manager) {
-    user_status_provider_ = base::MakeUnique<UserPolicyStatusProvider>(
+    user_status_provider_ = base::MakeUnique<UserCloudPolicyStatusProvider>(
         user_cloud_policy_manager->core());
   }
 #endif
 
   if (!user_status_provider_.get())
     user_status_provider_ = base::MakeUnique<PolicyStatusProvider>();
   if (!device_status_provider_.get())
     device_status_provider_ = base::MakeUnique<PolicyStatusProvider>();
 
   base::Closure update_callback(base::Bind(&PolicyUIHandler::SendStatus,
@@ skipping 238 matching lines @@
 }
 
 void PolicyUIHandler::OnRefreshPoliciesDone() const {
   web_ui()->CallJavascriptFunctionUnsafe("policy.Page.reloadPoliciesDone");
 }
 
 policy::PolicyService* PolicyUIHandler::GetPolicyService() const {
   return policy::ProfilePolicyConnectorFactory::GetForBrowserContext(
              web_ui()->GetWebContents()->GetBrowserContext())->policy_service();
 }