| Index: chrome/browser/policy/user_cloud_policy_store.cc
|
| diff --git a/chrome/browser/policy/user_cloud_policy_store.cc b/chrome/browser/policy/user_cloud_policy_store.cc
|
| deleted file mode 100644
|
| index f41f7a1c5cde1a5ae92ff6a89154fbb3ff2298df..0000000000000000000000000000000000000000
|
| --- a/chrome/browser/policy/user_cloud_policy_store.cc
|
| +++ /dev/null
|
| @@ -1,255 +0,0 @@
|
| -// 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/policy/user_cloud_policy_store.h"
|
| -
|
| -#include "base/bind.h"
|
| -#include "base/file_util.h"
|
| -#include "chrome/browser/policy/proto/cloud_policy.pb.h"
|
| -#include "chrome/browser/policy/proto/device_management_backend.pb.h"
|
| -#include "chrome/browser/policy/proto/device_management_local.pb.h"
|
| -#include "chrome/browser/profiles/profile.h"
|
| -#include "chrome/browser/signin/signin_manager.h"
|
| -#include "chrome/browser/signin/signin_manager_factory.h"
|
| -#include "content/public/browser/browser_thread.h"
|
| -#include "policy/policy_constants.h"
|
| -
|
| -namespace em = enterprise_management;
|
| -
|
| -namespace policy {
|
| -
|
| -enum PolicyLoadStatus {
|
| - // Policy blob was successfully loaded and parsed.
|
| - LOAD_RESULT_SUCCESS,
|
| -
|
| - // No previously stored policy was found.
|
| - LOAD_RESULT_NO_POLICY_FILE,
|
| -
|
| - // Could not load the previously stored policy due to either a parse or
|
| - // file read error.
|
| - LOAD_RESULT_LOAD_ERROR,
|
| -};
|
| -
|
| -// Struct containing the result of a policy load - if |status| ==
|
| -// LOAD_RESULT_SUCCESS, |policy| is initialized from the policy file on disk.
|
| -struct PolicyLoadResult {
|
| - PolicyLoadStatus status;
|
| - em::PolicyFetchResponse policy;
|
| -};
|
| -
|
| -namespace {
|
| -
|
| -// Subdirectory in the user's profile for storing user policies.
|
| -const base::FilePath::CharType kPolicyDir[] = FILE_PATH_LITERAL("Policy");
|
| -// File in the above directory for storing user policy data.
|
| -const base::FilePath::CharType kPolicyCacheFile[] =
|
| - FILE_PATH_LITERAL("User Policy");
|
| -
|
| -// Loads policy from the backing file. Returns a PolicyLoadResult with the
|
| -// results of the fetch.
|
| -policy::PolicyLoadResult LoadPolicyFromDisk(const base::FilePath& path) {
|
| - policy::PolicyLoadResult result;
|
| - // If the backing file does not exist, just return.
|
| - if (!file_util::PathExists(path)) {
|
| - result.status = policy::LOAD_RESULT_NO_POLICY_FILE;
|
| - return result;
|
| - }
|
| - std::string data;
|
| - if (!file_util::ReadFileToString(path, &data) ||
|
| - !result.policy.ParseFromArray(data.c_str(), data.size())) {
|
| - LOG(WARNING) << "Failed to read or parse policy data from " << path.value();
|
| - result.status = policy::LOAD_RESULT_LOAD_ERROR;
|
| - return result;
|
| - }
|
| -
|
| - result.status = policy::LOAD_RESULT_SUCCESS;
|
| - return result;
|
| -}
|
| -
|
| -// Stores policy to the backing file (must be called via a task on
|
| -// the FILE thread).
|
| -void StorePolicyToDiskOnFileThread(const base::FilePath& path,
|
| - const em::PolicyFetchResponse& policy) {
|
| - DVLOG(1) << "Storing policy to " << path.value();
|
| - DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
|
| - std::string data;
|
| - if (!policy.SerializeToString(&data)) {
|
| - DLOG(WARNING) << "Failed to serialize policy data";
|
| - return;
|
| - }
|
| -
|
| - if (!file_util::CreateDirectory(path.DirName())) {
|
| - DLOG(WARNING) << "Failed to create directory " << path.DirName().value();
|
| - return;
|
| - }
|
| -
|
| - int size = data.size();
|
| - if (file_util::WriteFile(path, data.c_str(), size) != size) {
|
| - DLOG(WARNING) << "Failed to write " << path.value();
|
| - }
|
| -}
|
| -
|
| -} // namespace
|
| -
|
| -UserCloudPolicyStore::UserCloudPolicyStore(Profile* profile,
|
| - const base::FilePath& path)
|
| - : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
|
| - profile_(profile),
|
| - backing_file_path_(path) {
|
| -}
|
| -
|
| -UserCloudPolicyStore::~UserCloudPolicyStore() {}
|
| -
|
| -// static
|
| -scoped_ptr<UserCloudPolicyStore> UserCloudPolicyStore::Create(
|
| - Profile* profile) {
|
| - base::FilePath path =
|
| - profile->GetPath().Append(kPolicyDir).Append(kPolicyCacheFile);
|
| - return make_scoped_ptr(new UserCloudPolicyStore(profile, path));
|
| -}
|
| -
|
| -void UserCloudPolicyStore::LoadImmediately() {
|
| - DVLOG(1) << "Initiating immediate policy load from disk";
|
| - // Cancel any pending Load/Store/Validate operations.
|
| - weak_factory_.InvalidateWeakPtrs();
|
| - // Load the policy from disk...
|
| - PolicyLoadResult result = LoadPolicyFromDisk(backing_file_path_);
|
| - // ...and install it, reporting success/failure to any observers.
|
| - PolicyLoaded(false, result);
|
| -}
|
| -
|
| -void UserCloudPolicyStore::Clear() {
|
| - content::BrowserThread::PostTask(
|
| - content::BrowserThread::FILE, FROM_HERE,
|
| - base::Bind(base::IgnoreResult(&file_util::Delete),
|
| - backing_file_path_,
|
| - false));
|
| - policy_.reset();
|
| - policy_map_.Clear();
|
| - NotifyStoreLoaded();
|
| -}
|
| -
|
| -void UserCloudPolicyStore::Load() {
|
| - DVLOG(1) << "Initiating policy load from disk";
|
| - // Cancel any pending Load/Store/Validate operations.
|
| - weak_factory_.InvalidateWeakPtrs();
|
| -
|
| - // Start a new Load operation and have us get called back when it is
|
| - // complete.
|
| - content::BrowserThread::PostTaskAndReplyWithResult(
|
| - content::BrowserThread::FILE, FROM_HERE,
|
| - base::Bind(&LoadPolicyFromDisk, backing_file_path_),
|
| - base::Bind(&UserCloudPolicyStore::PolicyLoaded,
|
| - weak_factory_.GetWeakPtr(), true));
|
| -}
|
| -
|
| -void UserCloudPolicyStore::PolicyLoaded(bool validate_in_background,
|
| - PolicyLoadResult result) {
|
| - DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
|
| - switch (result.status) {
|
| - case LOAD_RESULT_LOAD_ERROR:
|
| - status_ = STATUS_LOAD_ERROR;
|
| - NotifyStoreError();
|
| - break;
|
| -
|
| - case LOAD_RESULT_NO_POLICY_FILE:
|
| - DVLOG(1) << "No policy found on disk";
|
| - NotifyStoreLoaded();
|
| - break;
|
| -
|
| - case LOAD_RESULT_SUCCESS: {
|
| - // Found policy on disk - need to validate it before it can be used.
|
| - scoped_ptr<em::PolicyFetchResponse> cloud_policy(
|
| - new em::PolicyFetchResponse(result.policy));
|
| - Validate(cloud_policy.Pass(),
|
| - validate_in_background,
|
| - base::Bind(
|
| - &UserCloudPolicyStore::InstallLoadedPolicyAfterValidation,
|
| - weak_factory_.GetWeakPtr()));
|
| - break;
|
| - }
|
| - default:
|
| - NOTREACHED();
|
| - }
|
| -}
|
| -
|
| -void UserCloudPolicyStore::InstallLoadedPolicyAfterValidation(
|
| - UserCloudPolicyValidator* validator) {
|
| - validation_status_ = validator->status();
|
| - if (!validator->success()) {
|
| - DVLOG(1) << "Validation failed: status=" << validation_status_;
|
| - status_ = STATUS_VALIDATION_ERROR;
|
| - NotifyStoreError();
|
| - return;
|
| - }
|
| -
|
| - DVLOG(1) << "Validation succeeded - installing policy with dm_token: " <<
|
| - validator->policy_data()->request_token();
|
| - DVLOG(1) << "Device ID: " << validator->policy_data()->device_id();
|
| -
|
| - InstallPolicy(validator->policy_data().Pass(), validator->payload().Pass());
|
| - status_ = STATUS_OK;
|
| - NotifyStoreLoaded();
|
| -}
|
| -
|
| -void UserCloudPolicyStore::Store(const em::PolicyFetchResponse& policy) {
|
| - // Stop any pending requests to store policy, then validate the new policy
|
| - // before storing it.
|
| - weak_factory_.InvalidateWeakPtrs();
|
| - scoped_ptr<em::PolicyFetchResponse> policy_copy(
|
| - new em::PolicyFetchResponse(policy));
|
| - Validate(policy_copy.Pass(),
|
| - true,
|
| - base::Bind(&UserCloudPolicyStore::StorePolicyAfterValidation,
|
| - weak_factory_.GetWeakPtr()));
|
| -}
|
| -
|
| -void UserCloudPolicyStore::Validate(
|
| - scoped_ptr<em::PolicyFetchResponse> policy,
|
| - bool validate_in_background,
|
| - const UserCloudPolicyValidator::CompletionCallback& callback) {
|
| - // Configure the validator.
|
| - scoped_ptr<UserCloudPolicyValidator> validator =
|
| - CreateValidator(policy.Pass());
|
| - SigninManager* signin = SigninManagerFactory::GetForProfileIfExists(profile_);
|
| - if (signin) {
|
| - std::string username = signin->GetAuthenticatedUsername();
|
| - // Validate the username if the user is signed in.
|
| - if (!username.empty())
|
| - validator->ValidateUsername(username);
|
| - }
|
| -
|
| - if (validate_in_background) {
|
| - // Start validation in the background. The Validator will free itself once
|
| - // validation is complete.
|
| - validator.release()->StartValidation(callback);
|
| - } else {
|
| - // Run validation immediately and invoke the callback with the results.
|
| - validator->RunValidation();
|
| - callback.Run(validator.get());
|
| - }
|
| -}
|
| -
|
| -void UserCloudPolicyStore::StorePolicyAfterValidation(
|
| - UserCloudPolicyValidator* validator) {
|
| - validation_status_ = validator->status();
|
| - DVLOG(1) << "Policy validation complete: status = " << validation_status_;
|
| - if (!validator->success()) {
|
| - status_ = STATUS_VALIDATION_ERROR;
|
| - NotifyStoreError();
|
| - return;
|
| - }
|
| -
|
| - // Persist the validated policy (just fire a task - don't bother getting a
|
| - // reply because we can't do anything if it fails).
|
| - content::BrowserThread::PostTask(
|
| - content::BrowserThread::FILE, FROM_HERE,
|
| - base::Bind(&StorePolicyToDiskOnFileThread,
|
| - backing_file_path_, *validator->policy()));
|
| - InstallPolicy(validator->policy_data().Pass(), validator->payload().Pass());
|
| - status_ = STATUS_OK;
|
| - NotifyStoreLoaded();
|
| -}
|
| -
|
| -} // namespace policy
|
|
|