chrome/browser/chromeos/policy/server_backed_state_keys_broker.cc

// Copyright 2014 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/policy/server_backed_state_keys_broker.h"

#include <algorithm>

#include "base/bind.h"
#include "base/location.h"
#include "base/task_runner.h"
#include "chromeos/dbus/session_manager_client.h"

namespace policy {

namespace {

// Refresh interval for state keys. There's a quantized time component in
// state key generation, so they rotate over time. The quantum size is pretty
// coarse though (currently 2^23 seconds), so simply polling for a new state
// keys once a day is good enough.
const int kPollIntervalSeconds = 60 * 60 * 24;

}  // namespace

ServerBackedStateKeysBroker::ServerBackedStateKeysBroker(
    chromeos::SessionManagerClient* session_manager_client,
    scoped_refptr<base::TaskRunner> delayed_task_runner)
    : session_manager_client_(session_manager_client),
      delayed_task_runner_(delayed_task_runner),
      requested_(false),
      initial_retrieval_completed_(false),
      weak_factory_(this) {
}

ServerBackedStateKeysBroker::~ServerBackedStateKeysBroker() {
}

ServerBackedStateKeysBroker::Subscription
ServerBackedStateKeysBroker::RegisterUpdateCallback(
    const base::Closure& callback) {
  if (!available())
    FetchStateKeys();
  return update_callbacks_.Add(callback);
}

void ServerBackedStateKeysBroker::RequestStateKeys(
    const StateKeysCallback& callback) {
  if (pending()) {
    request_callbacks_.push_back(callback);
    FetchStateKeys();
    return;
  }

  if (!callback.is_null())
    callback.Run(state_keys_);
  return;
}

void ServerBackedStateKeysBroker::FetchStateKeys() {
  if (!requested_) {
    requested_ = true;
    session_manager_client_->GetServerBackedStateKeys(
        base::Bind(&ServerBackedStateKeysBroker::StoreStateKeys,
                   weak_factory_.GetWeakPtr()));
  }
}

void ServerBackedStateKeysBroker::StoreStateKeys(
    const std::vector<std::string>& state_keys) {
  bool send_notification = !initial_retrieval_completed_;

  requested_ = false;
  initial_retrieval_completed_ = true;
  if (state_keys.empty()) {
    LOG(WARNING) << "Failed to obtain server-backed state keys.";
  } else if (state_keys.end() !=
             std::find(state_keys.begin(), state_keys.end(), std::string())) {
    LOG(WARNING) << "Bad state keys.";
  } else {
    send_notification |= state_keys_ != state_keys;
    state_keys_ = state_keys;
  }

  if (send_notification)
    update_callbacks_.Notify();

  std::vector<StateKeysCallback> callbacks;
  request_callbacks_.swap(callbacks);
  for (std::vector<StateKeysCallback>::const_iterator callback(
           callbacks.begin());
       callback != callbacks.end();
       ++callback) {
    if (!callback->is_null())
      callback->Run(state_keys_);
  }

  delayed_task_runner_->PostDelayedTask(
      FROM_HERE,
      base::Bind(&ServerBackedStateKeysBroker::FetchStateKeys,
                 weak_factory_.GetWeakPtr()),
      base::TimeDelta::FromSeconds(kPollIntervalSeconds));
}

}  // namespace policy