Add DeviceADPolicyManager to provide AD policy.

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 17 matching lines @@
 #include "chrome/browser/policy/schema_registry_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/grit/policy_resources.h"
 #include "chrome/grit/policy_resources_map.h"
 #include "components/policy/core/browser/browser_policy_connector.h"
 #include "components/policy/core/browser/cloud/message_util.h"
 #include "components/policy/core/browser/configuration_policy_handler_list.h"
 #include "components/policy/core/common/cloud/cloud_policy_client.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "components/policy/core/common/cloud/cloud_policy_core.h"
+#include "components/policy/core/common/cloud/cloud_policy_manager.h"
 #include "components/policy/core/common/cloud/cloud_policy_refresh_scheduler.h"
 #include "components/policy/core/common/cloud/cloud_policy_store.h"
 #include "components/policy/core/common/cloud/cloud_policy_validator.h"
 #include "components/policy/core/common/policy_details.h"
 #include "components/policy/core/common/policy_types.h"
 #include "components/policy/core/common/remote_commands/remote_commands_service.h"
 #include "components/policy/core/common/schema.h"
 #include "components/policy/core/common/schema_map.h"
 #include "components/policy/policy_constants.h"
 #include "components/policy/proto/device_management_backend.pb.h"
 #include "components/strings/grit/components_strings.h"
 #include "content/public/browser/web_contents.h"
 #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_cloud_policy_manager_chromeos.h"
+#include "chrome/browser/chromeos/policy/device_ad_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_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 defined(ENABLE_EXTENSIONS)
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_constants.h"
 #endif
 
 namespace em = enterprise_management;
 
 namespace {
 
 // Strings that map from PolicySource enum to i18n string keys and their IDs.
 // Their order has to follow the order of the policy::PolicySource enum.
 const PolicyStringMap kPolicySources[policy::POLICY_SOURCE_COUNT] = {
-  {"sourceEnterpriseDefault", IDS_POLICY_SOURCE_ENTERPRISE_DEFAULT},
-  {"sourceCloud", IDS_POLICY_SOURCE_CLOUD},
-  {"sourcePublicSessionOverride", IDS_POLICY_SOURCE_PUBLIC_SESSION_OVERRIDE},
-  {"sourcePlatform", IDS_POLICY_SOURCE_PLATFORM},
+    {"sourceEnterpriseDefault", IDS_POLICY_SOURCE_ENTERPRISE_DEFAULT},
+    {"sourceCloud", IDS_POLICY_SOURCE_CLOUD},
+    {"sourceActiveDirectory", IDS_POLICY_SOURCE_ACTIVE_DIRECTORY},
+    {"sourcePublicSessionOverride", IDS_POLICY_SOURCE_PUBLIC_SESSION_OVERRIDE},
+    {"sourcePlatform", IDS_POLICY_SOURCE_PLATFORM},
 };
 
 // Formats the association state indicated by |data|. If |data| is NULL, the
 // state is considered to be UNMANAGED.
 base::string16 FormatAssociationState(const em::PolicyData* data) {
   if (data) {
     switch (data->state()) {
       case em::PolicyData::ACTIVE:
         return l10n_util::GetStringUTF16(IDS_POLICY_ASSOCIATION_STATE_ACTIVE);
       case em::PolicyData::UNMANAGED:
@@ skipping 96 matching lines @@
       if (list->GetDictionary(i, &dict))
         list->Set(i, DictionaryToJSONString(*dict));
     }
   }
 
   return copy;
 }
 
 }  // namespace
 
-// An interface for querying the status of cloud policy.
-class CloudPolicyStatusProvider {
+// An interface for querying the status of a policy provider.  It surfaces
+// things like last fetch time or status of the backing store, but not the
+// actual policies themselves.
+class PolicyStatusProvider {
  public:
-  CloudPolicyStatusProvider();
-  virtual ~CloudPolicyStatusProvider();
+  PolicyStatusProvider();
+  virtual ~PolicyStatusProvider();
 
   // Sets a callback to invoke upon status changes.
   void SetStatusChangeCallback(const base::Closure& callback);
 
   virtual void GetStatus(base::DictionaryValue* dict);
 
  protected:
   void NotifyStatusChange();
 
  private:
   base::Closure callback_;
 
-  DISALLOW_COPY_AND_ASSIGN(CloudPolicyStatusProvider);
+  DISALLOW_COPY_AND_ASSIGN(PolicyStatusProvider);
 };
 
 // Status provider implementation that pulls cloud policy status from a
 // CloudPolicyCore instance provided at construction time. Also listens for
 // changes on that CloudPolicyCore and reports them through the status change
 // callback.
 class CloudPolicyCoreStatusProvider
-    : public CloudPolicyStatusProvider,
+    : public PolicyStatusProvider,
       public policy::CloudPolicyStore::Observer {
  public:
   explicit CloudPolicyCoreStatusProvider(policy::CloudPolicyCore* core);
   ~CloudPolicyCoreStatusProvider() override;
 
   // policy::CloudPolicyStore::Observer implementation.
   void OnStoreLoaded(policy::CloudPolicyStore* store) override;
   void OnStoreError(policy::CloudPolicyStore* store) override;
 
  protected:
@@ skipping 35 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(DevicePolicyStatusProvider);
 };
 
 // A cloud policy status provider that reads policy status from the policy core
 // associated with the device-local account specified by |user_id| at
 // construction time. The indirection via user ID and
 // DeviceLocalAccountPolicyService is necessary because the device-local account
 // may go away any time behind the scenes, at which point the status message
 // text will indicate CloudPolicyStore::STATUS_BAD_STATE.
 class DeviceLocalAccountPolicyStatusProvider
-    : public CloudPolicyStatusProvider,
+    : public PolicyStatusProvider,
       public policy::DeviceLocalAccountPolicyService::Observer {
  public:
   DeviceLocalAccountPolicyStatusProvider(
       const std::string& user_id,
       policy::DeviceLocalAccountPolicyService* service);
   ~DeviceLocalAccountPolicyStatusProvider() override;
 
-  // CloudPolicyStatusProvider implementation.
+  // PolicyStatusProvider implementation.
   void GetStatus(base::DictionaryValue* dict) override;
 
   // policy::DeviceLocalAccountPolicyService::Observer implementation.
   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);
 };
+
+class DeviceADPolicyStatusProvider : public PolicyStatusProvider {

[emaxx, 2016/11/11 15:25:09]

Add a short comment for this class?

[Thiemo Nagel, 2016/11/16 19:11:01]

Done.

+ public:
+  explicit DeviceADPolicyStatusProvider(policy::DeviceADPolicyManager* manager);
+  ~DeviceADPolicyStatusProvider() override = default;

[emaxx, 2016/11/11 15:25:09]

Just curious: is this due to some compiler complaint?

[Thiemo Nagel, 2016/11/16 19:11:01]

No.  It's probably bad form because it creates an inline destructor.  Fixed.

+
+  // PolicyStatusProvider implementation.
+  void GetStatus(base::DictionaryValue* dict) override;
+
+ private:
+  const policy::CloudPolicyStore* store_;
+};
 #endif
 
-CloudPolicyStatusProvider::CloudPolicyStatusProvider() {
-}
+PolicyStatusProvider::PolicyStatusProvider() {}
 
-CloudPolicyStatusProvider::~CloudPolicyStatusProvider() {
-}
+PolicyStatusProvider::~PolicyStatusProvider() {}
 
-void CloudPolicyStatusProvider::SetStatusChangeCallback(
+void PolicyStatusProvider::SetStatusChangeCallback(
     const base::Closure& callback) {
   callback_ = callback;
 }
 
-void CloudPolicyStatusProvider::GetStatus(base::DictionaryValue* dict) {
-}
+void PolicyStatusProvider::GetStatus(base::DictionaryValue* dict) {}
 
-void CloudPolicyStatusProvider::NotifyStatusChange() {
+void PolicyStatusProvider::NotifyStatusChange() {
   if (!callback_.is_null())
     callback_.Run();
 }
 
 CloudPolicyCoreStatusProvider::CloudPolicyCoreStatusProvider(
     policy::CloudPolicyCore* core) : core_(core) {
   core_->store()->AddObserver(this);
   // TODO(bartfab): Add an observer that watches for client errors. Observing
   // core_->client() directly is not safe as the client may be destroyed and
   // (re-)created anytime if the user signs in or out on desktop platforms.
@@ skipping 76 matching lines @@
 
 void DeviceLocalAccountPolicyStatusProvider::OnPolicyUpdated(
     const std::string& user_id) {
   if (user_id == user_id_)
     NotifyStatusChange();
 }
 
 void DeviceLocalAccountPolicyStatusProvider::OnDeviceLocalAccountsChanged() {
   NotifyStatusChange();
 }
-#endif
+
+DeviceADPolicyStatusProvider::DeviceADPolicyStatusProvider(
+    policy::DeviceADPolicyManager* manager)
+    : store_(manager->store()) {}
+
+void DeviceADPolicyStatusProvider::GetStatus(base::DictionaryValue* dict) {
+  base::string16 status =
+      policy::FormatStoreStatus(store_->status(), store_->validation_status());
+  dict->SetString("status", status);
+}
+
+#endif  // defined(OS_CHROMEOS)
 
 PolicyUIHandler::PolicyUIHandler()
     : weak_factory_(this) {
 }
 
 PolicyUIHandler::~PolicyUIHandler() {
   GetPolicyService()->RemoveObserver(policy::POLICY_DOMAIN_CHROME, this);
   GetPolicyService()->RemoveObserver(policy::POLICY_DOMAIN_EXTENSIONS, this);
   policy::SchemaRegistry* registry =
       policy::SchemaRegistryServiceFactory::GetForContext(
@@ skipping 33 matching lines @@
   source->AddLocalizedString("unset", IDS_POLICY_UNSET);
   source->AddLocalizedString("unknown", IDS_POLICY_UNKNOWN);
   source->AddLocalizedString("notSpecified", IDS_POLICY_NOT_SPECIFIED);
   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())
-    device_status_provider_.reset(new DevicePolicyStatusProvider(connector));
+  if (connector->IsEnterpriseManaged()) {
+    if (connector->GetDeviceADPolicyManager()) {
+      device_status_provider_ = base::MakeUnique<DeviceADPolicyStatusProvider>(
+          connector->GetDeviceADPolicyManager());
+    } 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_.reset(new DeviceLocalAccountPolicyStatusProvider(
           user_manager->GetLoggedInUser()->GetAccountId().GetUserEmail(),
           local_account_service));
@@ skipping 11 matching lines @@
   policy::UserCloudPolicyManager* user_cloud_policy_manager =
       policy::UserCloudPolicyManagerFactory::GetForBrowserContext(
           web_ui()->GetWebContents()->GetBrowserContext());
   if (user_cloud_policy_manager) {
     user_status_provider_.reset(
         new UserPolicyStatusProvider(user_cloud_policy_manager->core()));
   }
 #endif
 
   if (!user_status_provider_.get())
-    user_status_provider_.reset(new CloudPolicyStatusProvider());
+    user_status_provider_.reset(new PolicyStatusProvider());
   if (!device_status_provider_.get())
-    device_status_provider_.reset(new CloudPolicyStatusProvider());
+    device_status_provider_.reset(new PolicyStatusProvider());
 
   base::Closure update_callback(base::Bind(&PolicyUIHandler::SendStatus,
                                            base::Unretained(this)));
   user_status_provider_->SetStatusChangeCallback(update_callback);
   device_status_provider_->SetStatusChangeCallback(update_callback);
   GetPolicyService()->AddObserver(policy::POLICY_DOMAIN_CHROME, this);
   GetPolicyService()->AddObserver(policy::POLICY_DOMAIN_EXTENSIONS, this);
 
 #if defined(ENABLE_EXTENSIONS)
   extensions::ExtensionRegistry::Get(Profile::FromWebUI(web_ui()))
@@ skipping 206 matching lines @@
   SendPolicyValues();
   SendStatus();
 }
 
 void PolicyUIHandler::HandleReloadPolicies(const base::ListValue* args) {
 #if defined(OS_CHROMEOS)
   // Allow user to manually fetch remote commands, in case invalidation
   // service is not working properly.
   // TODO(binjin): evaluate and possibly remove this after invalidation
   // service is landed and tested. http://crbug.com/480982
-  policy::BrowserPolicyConnectorChromeOS* connector =
-      g_browser_process->platform_part()->browser_policy_connector_chromeos();
-  policy::RemoteCommandsService* remote_commands_service =
-      connector->GetDeviceCloudPolicyManager()
-          ->core()
-          ->remote_commands_service();
-  if (remote_commands_service)
-    remote_commands_service->FetchRemoteCommands();
+  policy::CloudPolicyManager* manager =
+      g_browser_process->platform_part()
+          ->browser_policy_connector_chromeos()
+          ->GetDeviceCloudPolicyManager();
+  if (manager) {
+    policy::RemoteCommandsService* remote_commands_service =
+        manager->core()->remote_commands_service();
+    if (remote_commands_service)
+      remote_commands_service->FetchRemoteCommands();
+  }
 #endif
   GetPolicyService()->RefreshPolicies(base::Bind(
       &PolicyUIHandler::OnRefreshPoliciesDone, weak_factory_.GetWeakPtr()));
 }
 
 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();
 }