Make GetPolicies() return null for unmanaged users

chrome/browser/chromeos/arc/arc_policy_bridge.cc

 // Copyright 2016 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_policy_bridge.h"
 
 #include <memory>
 #include <string>
 
 #include "base/json/json_reader.h"
@@ skipping 134 matching lines @@
       policy_service_(policy_service) {
   VLOG(1) << "ArcPolicyBridge::ArcPolicyBridge(bridge_service, policy_service)";
   arc_bridge_service()->AddObserver(this);
 }
 
 ArcPolicyBridge::~ArcPolicyBridge() {
   VLOG(1) << "ArcPolicyBridge::~ArcPolicyBridge";
   arc_bridge_service()->RemoveObserver(this);
 }
 
+void ArcPolicyBridge::OverrideIsManagedForTesting(bool is_managed) {
+  is_managed_ = is_managed;
+}
+
 void ArcPolicyBridge::OnPolicyInstanceReady() {
   VLOG(1) << "ArcPolicyBridge::OnPolicyInstanceReady";
   if (policy_service_ == nullptr) {
     InitializePolicyService();
   }
   policy_service_->AddObserver(policy::POLICY_DOMAIN_CHROME, this);
 
   mojom::PolicyInstance* const policy_instance =
       arc_bridge_service()->policy_instance();
   if (!policy_instance) {
     LOG(ERROR) << "OnPolicyInstanceReady called, but no policy instance found";
     return;
   }
 
   policy_instance->Init(binding_.CreateInterfacePtrAndBind());
 }
 
 void ArcPolicyBridge::OnPolicyInstanceClosed() {
   VLOG(1) << "ArcPolicyBridge::OnPolicyInstanceClosed";
   policy_service_->RemoveObserver(policy::POLICY_DOMAIN_CHROME, this);
   policy_service_ = nullptr;
 }
 
 void ArcPolicyBridge::GetPolicies(const GetPoliciesCallback& callback) {
   VLOG(1) << "ArcPolicyBridge::GetPolicies";
+  if (!is_managed_) {
+    callback.Run(mojo::String(nullptr));
+    return;
+  }
   const policy::PolicyNamespace policy_namespace(policy::POLICY_DOMAIN_CHROME,
                                                  std::string());
   const policy::PolicyMap& policy_map =
       policy_service_->GetPolicies(policy_namespace);
   const std::string json_policies = GetFilteredJSONPolicies(policy_map);
   callback.Run(mojo::String(json_policies));
 }
 
 void ArcPolicyBridge::OnPolicyUpdated(const policy::PolicyNamespace& ns,
                                       const policy::PolicyMap& previous,
                                       const policy::PolicyMap& current) {
   VLOG(1) << "ArcPolicyBridge::OnPolicyUpdated";
   DCHECK(arc_bridge_service()->policy_instance());
   arc_bridge_service()->policy_instance()->OnPolicyUpdated();
 }
 
 void ArcPolicyBridge::InitializePolicyService() {
   const user_manager::User* const primary_user =
       user_manager::UserManager::Get()->GetPrimaryUser();
   Profile* const profile =
       chromeos::ProfileHelper::Get()->GetProfileByUser(primary_user);
-  policy_service_ =
-      policy::ProfilePolicyConnectorFactory::GetForBrowserContext(profile)
-          ->policy_service();
+  auto profile_policy_connector =
+      policy::ProfilePolicyConnectorFactory::GetForBrowserContext(profile);
+  policy_service_ = profile_policy_connector->policy_service();
+  is_managed_ = profile_policy_connector->IsManaged();
 }
 
 }  // namespace arc