Device policy infrastructure

chrome/browser/policy/cloud_policy_subsystem.cc

Index: chrome/browser/policy/cloud_policy_subsystem.cc
diff --git a/chrome/browser/policy/cloud_policy_subsystem.cc b/chrome/browser/policy/cloud_policy_subsystem.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ce4fe38d58238941a44a6d1f43460e784982b976
--- /dev/null
+++ b/chrome/browser/policy/cloud_policy_subsystem.cc
@@ -0,0 +1,124 @@
+// 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/cloud_policy_subsystem.h"
+
+#include <algorithm>
+#include <string>
+
+#include "base/command_line.h"
+#include "chrome/browser/policy/cloud_policy_cache.h"
+#include "chrome/browser/policy/cloud_policy_controller.h"
+#include "chrome/browser/policy/cloud_policy_identity_strategy.h"
+#include "chrome/browser/policy/configuration_policy_provider.h"
+#include "chrome/browser/policy/device_management_service.h"
+#include "chrome/browser/policy/device_token_fetcher.h"
+#include "chrome/common/chrome_switches.h"
+#include "chrome/common/notification_details.h"
+#include "chrome/common/notification_source.h"
+#include "chrome/common/notification_type.h"
+
+namespace {
+
+// Refresh rate sanity interval bounds.
+const int64 kPolicyRefreshRateMinMs = 30 * 60 * 1000;  // 30 minutes
+const int64 kPolicyRefreshRateMaxMs = 24 * 60 * 60 * 1000;  // 1 day
+
+}  // namespace
+
+namespace policy {
+
+CloudPolicySubsystem::CloudPolicySubsystem(
+    const FilePath& policy_cache_file,
+    CloudPolicyIdentityStrategy* identity_strategy)
+    : prefs_(NULL) {
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kDeviceManagementUrl)) {
+    device_management_service_.reset(new DeviceManagementService(
+        command_line->GetSwitchValueASCII(switches::kDeviceManagementUrl)));
+    cloud_policy_cache_.reset(new CloudPolicyCache(policy_cache_file));
+    cloud_policy_cache_->LoadFromFile();
+
+    device_token_fetcher_.reset(
+        new DeviceTokenFetcher(device_management_service_.get(),
+                               cloud_policy_cache_.get()));
+
+    cloud_policy_controller_.reset(
+        new CloudPolicyController(cloud_policy_cache_.get(),
+                                  device_management_service_->CreateBackend(),
+                                  device_token_fetcher_.get(),
+                                  identity_strategy));
+  }
+}
+
+CloudPolicySubsystem::~CloudPolicySubsystem() {
+  DCHECK(!prefs_);
+  cloud_policy_controller_.reset();
+  device_token_fetcher_.reset();
+  cloud_policy_cache_.reset();
+  device_management_service_.reset();
+}
+
+void CloudPolicySubsystem::Initialize(
+    PrefService* prefs,
+    const char* refresh_rate_pref_name,
+    URLRequestContextGetter* request_context) {
+  DCHECK(!prefs_);
+  prefs_ = prefs;
+
+  if (device_management_service_.get())
+    device_management_service_->Initialize(request_context);

[brettw, 2011/02/14 17:49:31]

It looks like this function starts a URL request, and you're doing this on the
startup path. Is that correct? Is there a way to delay this request for a bit
after startup?

[Mattias Nissler (ping if slow), 2011/02/14 18:55:58]

Some background information:
- This code is currently CrOS only, since we don't have cloud policy enabled for
desktop Chrome at the moment (though we're planning to eventually do so)
- The request will only be generated if we already know that we need to recheck
for cloud policy. This is only the case if the user is set up for cloud policy
and the cache file is invalid or too old.
- There are actually two instances of CloudPolicySubsystem. One is for user
policy that is bound to a profile (affects e.g. homepage URL). We initialize the
cloud policy stuff after the profile is up, because we want to have up-to-date
policy configuration as soon as possible after firing up the browser.
- The second instance of CloudPolicySubsystem is concerned with CrOS device
policy. It's started as soon as the default request context (to be replaced by
willchan's system request context eventually) is up, since we need the
up-to-date cloud policy information in order to make a call on whether we want
to accept a user to log on to CrOS (in case the user white list is managed
through policy)

Bottom line: I think the requests happen at the right time and delaying them is
either not helpful/appropriate. Moreover, we try hard to only make the requests
when policy is actually in effect for the user/device. I'm happy to discuss
further if you still have concerns!

[brettw, 2011/02/14 19:15:35]

Everybody wants everything as soon as possible. The question here is whether you
want to slow down the main window appearing. It seems impossible for the initial
homepage display to be affected by this request since it will happen too fast.
Since you've already lost that initial display, why not allow the window to come
up a bit faster? We do this whenever possible.

This seems to me to be a lot like chrome/browser/google/google_url_tracker.cc
which is trying to find the correct country-specific URL to use for searches if
you have your search provider set to Google. In both cases there's a cache, a
network request, and the response affects "stuff you want to do right away"
after starting the browser. You can see that code has a 5 second timer. Given
that we've put so much effort into this kind of thing in the past, I'm not sure
how your case is different.
Okay, and I assume you don't allow login until this response has completed?

Brett

[Mattias Nissler (ping if slow), 2011/02/14 19:38:56]

That sounds reasonable. However, I'm not yet buying the argument that not
generating the request will make the window come up faster. The request
processing happens asynchronously on the IO thread, so why would we see slowdown
(assuming number of cores is > 1)?

The other thing is that we want to actually notify the user when we learn policy
is in effect through an infobar. I'm a bit concerned about the UX on CrOS: With
the delay you log on, wait five seconds, and then magically your policy arrives
modifies your toolbar and you see the infobar, whereas when we fetch immediately
you log on and (assuming the server answers in reasonable time) get the toolbar
change and infobar close to instantly (Note we've already made the compromise
not to block CrOS login waiting for policy).
It's different in that delaying it affects UX much more as explained above. But
I can see that it's similar in the other points you brought up.
That's the plan, details TBD.

[Jakob Kummerow, 2011/02/21 12:12:15]

<snip: long discussion about delaying this method's work for the benefit of
faster browser startup>

As discussed, since fixing this existing sub-optimal behavior is not in the
scope of this CL, we will land it as is for now, but put in a comment describing
the problem and fix it soon in another CL. 

+
+  policy_refresh_rate_.Init(refresh_rate_pref_name, prefs_, this);
+  UpdatePolicyRefreshRate();
+}
+
+void CloudPolicySubsystem::Shutdown() {
+  if (device_management_service_.get())
+    device_management_service_->Shutdown();
+  cloud_policy_controller_.reset();
+  cloud_policy_cache_.reset();
+  policy_refresh_rate_.Destroy();
+  prefs_ = NULL;
+}
+
+ConfigurationPolicyProvider* CloudPolicySubsystem::GetManagedPolicyProvider() {
+  if (cloud_policy_cache_.get())
+    return cloud_policy_cache_->GetManagedPolicyProvider();
+
+  return NULL;
+}
+
+ConfigurationPolicyProvider*
+    CloudPolicySubsystem::GetRecommendedPolicyProvider() {
+  if (cloud_policy_cache_.get())
+    return cloud_policy_cache_->GetRecommendedPolicyProvider();
+
+  return NULL;
+}
+
+void CloudPolicySubsystem::UpdatePolicyRefreshRate() {
+  if (cloud_policy_controller_.get()) {
+    // Clamp to sane values.
+    int64 refresh_rate = policy_refresh_rate_.GetValue();
+    refresh_rate = std::max(kPolicyRefreshRateMinMs, refresh_rate);
+    refresh_rate = std::min(kPolicyRefreshRateMaxMs, refresh_rate);
+    cloud_policy_controller_->SetRefreshRate(refresh_rate);
+  }
+}
+
+void CloudPolicySubsystem::Observe(NotificationType type,
+                                   const NotificationSource& source,
+                                   const NotificationDetails& details) {
+  if (type == NotificationType::PREF_CHANGED &&
+      policy_refresh_rate_.GetPrefName()
+          == *(Details<std::string>(details).ptr()) &&
+      prefs_ == Source<PrefService>(source).ptr()) {
+    UpdatePolicyRefreshRate();
+  } else {
+    NOTREACHED();
+  }
+}
+
+}  // namespace policy