Move user cloud policy to BrowserProcess (was 6979011)

chrome/browser/policy/user_policy_cache.cc

 // Copyright (c) 2011 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/policy/user_policy_cache.h"
 
 #include <limits>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/values.h"
-#include "chrome/browser/policy/configuration_policy_pref_store.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/policy/browser_policy_connector.h"
+#include "chrome/browser/policy/cloud_policy_provider.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "chrome/browser/policy/proto/cloud_policy.pb.h"
 #include "chrome/browser/policy/proto/device_management_local.pb.h"
 #include "chrome/browser/policy/proto/old_generic_format.pb.h"
 #include "policy/configuration_policy_type.h"
 
 namespace policy {
 
 // Decodes a CloudPolicySettings object into two maps with mandatory and
 // recommended settings, respectively. The implementation is generated code
 // in policy/cloud_policy_generated.cc.
 void DecodePolicy(const em::CloudPolicySettings& policy,
                   PolicyMap* mandatory, PolicyMap* recommended);
 
 UserPolicyCache::UserPolicyCache(const FilePath& backing_file_path)
-    : ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
+    : ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
+      first_load_complete_(false) {
   disk_cache_ = new UserPolicyDiskCache(weak_ptr_factory_.GetWeakPtr(),
                                         backing_file_path);
 }
 
 UserPolicyCache::~UserPolicyCache() {
 }
 
 void UserPolicyCache::Load() {
   disk_cache_->Load();
 }
@@ skipping 20 matching lines @@
 void UserPolicyCache::SetUnmanaged() {
   DCHECK(CalledOnValidThread());
   SetUnmanagedInternal(base::Time::NowFromSystemTime());
 
   em::CachedCloudPolicyResponse cached_policy;
   cached_policy.set_unmanaged(true);
   cached_policy.set_timestamp(base::Time::NowFromSystemTime().ToTimeT());
   disk_cache_->Store(cached_policy);
 }
 
+bool UserPolicyCache::IsReady() {
+  return initialization_complete() || first_load_complete_;
+}
+
 void UserPolicyCache::OnDiskCacheLoaded(
     const em::CachedCloudPolicyResponse& cached_response) {
+  first_load_complete_ = true;
   if (initialization_complete())
     return;
 
   if (cached_response.unmanaged()) {
     SetUnmanagedInternal(base::Time::FromTimeT(cached_response.timestamp()));
   } else if (cached_response.has_cloud_policy()) {
     base::Time timestamp;
     if (SetPolicyInternal(cached_response.cloud_policy(), &timestamp, true))
       set_last_policy_refresh_time(timestamp);
   }
@@ skipping 60 matching lines @@
        ++named_value) {
     if (named_value->has_value()) {
       Value* decoded_value = DecodeValue(named_value->value());
       if (decoded_value)
         result.Set(named_value->name(), decoded_value);
     }
   }
   // Hack: Let one of the providers do the transformation from DictionaryValue
   // to PolicyMap, since they have the required code anyway.
   PolicyMapProxy map_proxy(mandatory);
-  GetManagedPolicyProvider()->ApplyPolicyValueTree(&result, &map_proxy);
+  g_browser_process->browser_policy_connector()->GetManagedCloudProvider()->
+      ApplyPolicyValueTree(&result, &map_proxy);
 }
 
 Value* UserPolicyCache::DecodeIntegerValue(
     google::protobuf::int64 value) const {
   if (value < std::numeric_limits<int>::min() ||
       value > std::numeric_limits<int>::max()) {
     LOG(WARNING) << "Integer value " << value
                  << " out of numeric limits, ignoring.";
     return NULL;
   }
@@ skipping 63 matching lines @@
       return list;
     }
     default:
       NOTREACHED() << "Unhandled value type";
   }
 
   return NULL;
 }
 
 }  // namespace policy