1// Copyright (c) 2011 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 "chrome/browser/policy/cloud_policy_subsystem.h"
6
7#include <algorithm>
8#include <string>
9
10#include "base/command_line.h"
11#include "chrome/browser/policy/cloud_policy_cache_base.h"
12#include "chrome/browser/policy/cloud_policy_controller.h"
13#include "chrome/browser/policy/cloud_policy_identity_strategy.h"
14#include "chrome/browser/policy/configuration_policy_provider.h"
15#include "chrome/browser/policy/device_management_service.h"
16#include "chrome/browser/policy/device_token_fetcher.h"
17#include "chrome/browser/policy/policy_notifier.h"
18#include "chrome/browser/prefs/pref_service.h"
19#include "chrome/common/chrome_switches.h"
20#include "chrome/common/pref_names.h"
21#include "content/common/notification_details.h"
22#include "content/common/notification_source.h"
23#include "content/common/notification_type.h"
24
25namespace {
26
27// Default refresh rate.
28const int kDefaultPolicyRefreshRateMs = 3 * 60 * 60 * 1000;  // 3 hours.
29
30// Refresh rate sanity interval bounds.
31const int64 kPolicyRefreshRateMinMs = 30 * 60 * 1000;  // 30 minutes
32const int64 kPolicyRefreshRateMaxMs = 24 * 60 * 60 * 1000;  // 1 day
33
34}  // namespace
35
36namespace policy {
37
38CloudPolicySubsystem::ObserverRegistrar::ObserverRegistrar(
39    CloudPolicySubsystem* cloud_policy_subsystem,
40    CloudPolicySubsystem::Observer* observer)
41    : observer_(observer) {
42  policy_notifier_ = cloud_policy_subsystem->notifier();
43  policy_notifier_->AddObserver(observer);
44}
45
46CloudPolicySubsystem::ObserverRegistrar::~ObserverRegistrar() {
47  if (policy_notifier_)
48    policy_notifier_->RemoveObserver(observer_);
49}
50
51CloudPolicySubsystem::CloudPolicySubsystem(
52    CloudPolicyIdentityStrategy* identity_strategy,
53    CloudPolicyCacheBase* policy_cache)
54    : prefs_(NULL) {
55  net::NetworkChangeNotifier::AddIPAddressObserver(this);
56  notifier_.reset(new PolicyNotifier());
57  CommandLine* command_line = CommandLine::ForCurrentProcess();
58  if (command_line->HasSwitch(switches::kDeviceManagementUrl)) {
59    device_management_service_.reset(new DeviceManagementService(
60        command_line->GetSwitchValueASCII(switches::kDeviceManagementUrl)));
61    cloud_policy_cache_.reset(policy_cache);
62    cloud_policy_cache_->set_policy_notifier(notifier_.get());
63    cloud_policy_cache_->Load();
64
65    device_token_fetcher_.reset(
66        new DeviceTokenFetcher(device_management_service_.get(),
67                               cloud_policy_cache_.get(),
68                               notifier_.get()));
69
70    cloud_policy_controller_.reset(
71        new CloudPolicyController(device_management_service_.get(),
72                                  cloud_policy_cache_.get(),
73                                  device_token_fetcher_.get(),
74                                  identity_strategy,
75                                  notifier_.get()));
76  }
77}
78
79CloudPolicySubsystem::~CloudPolicySubsystem() {
80  DCHECK(!prefs_);
81  cloud_policy_controller_.reset();
82  device_token_fetcher_.reset();
83  cloud_policy_cache_.reset();
84  device_management_service_.reset();
85  net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
86}
87
88void CloudPolicySubsystem::OnIPAddressChanged() {
89  if (state() == CloudPolicySubsystem::NETWORK_ERROR &&
90      cloud_policy_controller_.get()) {
91    cloud_policy_controller_->Retry();
92  }
93}
94
95void CloudPolicySubsystem::Initialize(
96    PrefService* prefs,
97    net::URLRequestContextGetter* request_context) {
98  DCHECK(!prefs_);
99  prefs_ = prefs;
100
101  if (device_management_service_.get())
102    device_management_service_->Initialize(request_context);
103
104  policy_refresh_rate_.Init(prefs::kPolicyRefreshRate, prefs_, this);
105  UpdatePolicyRefreshRate();
106}
107
108void CloudPolicySubsystem::Shutdown() {
109  if (device_management_service_.get())
110    device_management_service_->Shutdown();
111  cloud_policy_controller_.reset();
112  cloud_policy_cache_.reset();
113  policy_refresh_rate_.Destroy();
114  prefs_ = NULL;
115}
116
117CloudPolicySubsystem::PolicySubsystemState CloudPolicySubsystem::state() {
118  return notifier_->state();
119}
120
121CloudPolicySubsystem::ErrorDetails CloudPolicySubsystem::error_details() {
122  return notifier_->error_details();
123}
124
125void CloudPolicySubsystem::StopAutoRetry() {
126  cloud_policy_controller_->StopAutoRetry();
127  device_token_fetcher_->StopAutoRetry();
128}
129
130ConfigurationPolicyProvider* CloudPolicySubsystem::GetManagedPolicyProvider() {
131  if (cloud_policy_cache_.get())
132    return cloud_policy_cache_->GetManagedPolicyProvider();
133
134  return NULL;
135}
136
137ConfigurationPolicyProvider*
138    CloudPolicySubsystem::GetRecommendedPolicyProvider() {
139  if (cloud_policy_cache_.get())
140    return cloud_policy_cache_->GetRecommendedPolicyProvider();
141
142  return NULL;
143}
144
145// static
146void CloudPolicySubsystem::RegisterPrefs(PrefService* pref_service) {
147  pref_service->RegisterIntegerPref(prefs::kPolicyRefreshRate,
148                                    kDefaultPolicyRefreshRateMs);
149}
150
151void CloudPolicySubsystem::UpdatePolicyRefreshRate() {
152  if (cloud_policy_controller_.get()) {
153    // Clamp to sane values.
154    int64 refresh_rate = policy_refresh_rate_.GetValue();
155    refresh_rate = std::max(kPolicyRefreshRateMinMs, refresh_rate);
156    refresh_rate = std::min(kPolicyRefreshRateMaxMs, refresh_rate);
157    cloud_policy_controller_->SetRefreshRate(refresh_rate);
158  }
159}
160
161void CloudPolicySubsystem::Observe(NotificationType type,
162                                   const NotificationSource& source,
163                                   const NotificationDetails& details) {
164  if (type == NotificationType::PREF_CHANGED &&
165      policy_refresh_rate_.GetPrefName() ==
166          *(Details<std::string>(details).ptr()) &&
167      prefs_ == Source<PrefService>(source).ptr()) {
168    UpdatePolicyRefreshRate();
169  } else {
170    NOTREACHED();
171  }
172}
173
174}  // namespace policy
175