components/policy/core/common/cloud/cloud_policy_service.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/policy/core/common/cloud/cloud_policy_service.h"
   6
   7 #include "base/callback.h"
   8 #include "policy/proto/device_management_backend.pb.h"
   9
  10 namespace em = enterprise_management;
  11
  12 namespace policy {
  13
  14 CloudPolicyService::CloudPolicyService(const PolicyNamespaceKey& policy_ns_key,
  15                                        CloudPolicyClient* client,
  16                                        CloudPolicyStore* store)
  17     : policy_ns_key_(policy_ns_key),
  18       client_(client),
  19       store_(store),
  20       refresh_state_(REFRESH_NONE),
  21       initialization_complete_(false) {
  22   client_->AddNamespaceToFetch(policy_ns_key_);
  23   client_->AddObserver(this);
  24   store_->AddObserver(this);
  25
  26   // Make sure we initialize |client_| from the policy data that might be
  27   // already present in |store_|.
  28   OnStoreLoaded(store_);
  29 }
  30
  31 CloudPolicyService::~CloudPolicyService() {
  32   client_->RemoveNamespaceToFetch(policy_ns_key_);
  33   client_->RemoveObserver(this);
  34   store_->RemoveObserver(this);
  35 }
  36
  37 std::string CloudPolicyService::ManagedBy() const {
  38   const em::PolicyData* policy = store_->policy();
  39   if (policy) {
  40     std::string username = policy->username();
  41     std::size_t pos = username.find('@');
  42     if (pos != std::string::npos)
  43       return username.substr(pos + 1);
  44   }
  45   return std::string();
  46 }
  47
  48 void CloudPolicyService::RefreshPolicy(const RefreshPolicyCallback& callback) {
  49   // If the client is not registered, bail out.
  50   if (!client_->is_registered()) {
  51     callback.Run(false);
  52     return;
  53   }
  54
  55   // Else, trigger a refresh.
  56   refresh_callbacks_.push_back(callback);
  57   refresh_state_ = REFRESH_POLICY_FETCH;
  58   client_->FetchPolicy();
  59 }
  60
  61 void CloudPolicyService::OnPolicyFetched(CloudPolicyClient* client) {
  62   if (client_->status() != DM_STATUS_SUCCESS) {
  63     RefreshCompleted(false);
  64     return;
  65   }
  66
  67   const em::PolicyFetchResponse* policy = client_->GetPolicyFor(policy_ns_key_);
  68   if (policy) {
  69     if (refresh_state_ != REFRESH_NONE)
  70       refresh_state_ = REFRESH_POLICY_STORE;
  71     store_->Store(*policy, client->fetched_invalidation_version());
  72   } else {
  73     RefreshCompleted(false);
  74   }
  75 }
  76
  77 void CloudPolicyService::OnRegistrationStateChanged(CloudPolicyClient* client) {
  78 }
  79
  80 void CloudPolicyService::OnClientError(CloudPolicyClient* client) {
  81   if (refresh_state_ == REFRESH_POLICY_FETCH)
  82     RefreshCompleted(false);
  83 }
  84
  85 void CloudPolicyService::OnStoreLoaded(CloudPolicyStore* store) {
  86   // Update the client with state from the store.
  87   const em::PolicyData* policy(store_->policy());
  88
  89   // Timestamp.
  90   base::Time policy_timestamp;
  91   if (policy && policy->has_timestamp()) {
  92     policy_timestamp =
  93         base::Time::UnixEpoch() +
  94         base::TimeDelta::FromMilliseconds(policy->timestamp());
  95   }
  96   client_->set_last_policy_timestamp(policy_timestamp);
  97
  98   // Public key version.
  99   if (policy && policy->has_public_key_version())
 100     client_->set_public_key_version(policy->public_key_version());
 101   else
 102     client_->clear_public_key_version();
 103
 104   // Whether to submit the machine ID.
 105   bool submit_machine_id = false;
 106   if (policy && policy->has_valid_serial_number_missing())
 107     submit_machine_id = policy->valid_serial_number_missing();
 108   client_->set_submit_machine_id(submit_machine_id);
 109
 110   // Finally, set up registration if necessary.
 111   if (policy && policy->has_request_token() && policy->has_device_id() &&
 112       !client_->is_registered()) {
 113     DVLOG(1) << "Setting up registration with request token: "
 114              << policy->request_token();
 115     client_->SetupRegistration(policy->request_token(),
 116                                policy->device_id());
 117   }
 118
 119   if (refresh_state_ == REFRESH_POLICY_STORE)
 120     RefreshCompleted(true);
 121
 122   CheckInitializationCompleted();
 123 }
 124
 125 void CloudPolicyService::OnStoreError(CloudPolicyStore* store) {
 126   if (refresh_state_ == REFRESH_POLICY_STORE)
 127     RefreshCompleted(false);
 128   CheckInitializationCompleted();
 129 }
 130
 131 void CloudPolicyService::CheckInitializationCompleted() {
 132   if (!IsInitializationComplete() && store_->is_initialized()) {
 133     initialization_complete_ = true;
 134     FOR_EACH_OBSERVER(Observer, observers_, OnInitializationCompleted(this));
 135   }
 136 }
 137
 138 void CloudPolicyService::RefreshCompleted(bool success) {
 139   // Clear state and |refresh_callbacks_| before actually invoking them, s.t.
 140   // triggering new policy fetches behaves as expected.
 141   std::vector<RefreshPolicyCallback> callbacks;
 142   callbacks.swap(refresh_callbacks_);
 143   refresh_state_ = REFRESH_NONE;
 144
 145   for (std::vector<RefreshPolicyCallback>::iterator callback(callbacks.begin());
 146        callback != callbacks.end();
 147        ++callback) {
 148     callback->Run(success);
 149   }
 150 }
 151
 152 void CloudPolicyService::AddObserver(Observer* observer) {
 153   observers_.AddObserver(observer);
 154 }
 155
 156 void CloudPolicyService::RemoveObserver(Observer* observer) {
 157   observers_.RemoveObserver(observer);
 158 }
 159
 160 }  // namespace policy