Implemented status section functionality for about:policy.

chrome/browser/ui/webui/policy_ui.cc

 // 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/ui/webui/policy_ui.h"
 
-#include "chrome/browser/policy/policy_status_info.h"
+#include "base/i18n/time_formatting.h"
+#include "base/utf_string_conversions.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/chromeos/login/user_manager.h"
+#include "chrome/browser/prefs/pref_service.h"
+#include "chrome/browser/policy/browser_policy_connector.h"
+#include "chrome/browser/policy/cloud_policy_cache_base.h"
+#include "chrome/browser/policy/cloud_policy_data_store.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"

[Mattias Nissler (ping if slow), 2011/09/02 11:16:09]

What do you need ProfileManager for?

[simo, 2011/09/02 15:32:02]

Oh, nothing, forgot to take that out.

 #include "chrome/browser/ui/webui/chrome_web_ui_data_source.h"
+#include "chrome/common/time_format.h"
+#include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "grit/browser_resources.h"
 #include "grit/generated_resources.h"
 
 ChromeWebUIDataSource* CreatePolicyUIHTMLSource() {
   ChromeWebUIDataSource* source =
       new ChromeWebUIDataSource(chrome::kChromeUIPolicyHost);
 
   // Localized strings.
   source->AddLocalizedString("policyTitle", IDS_POLICY_TITLE);
   source->AddLocalizedString("statusPaneTitle", IDS_POLICY_STATUS_TITLE);
   source->AddLocalizedString("fetchPoliciesText", IDS_POLICY_FETCH);
   source->AddLocalizedString("devicePoliciesBoxTitle",
                              IDS_POLICY_DEVICE_POLICIES);
   source->AddLocalizedString("userPoliciesBoxTitle",
                              IDS_POLICY_USER_POLICIES);
   source->AddLocalizedString("enrollmentDomainText",
                              IDS_POLICY_ENROLLMENT_DOMAIN);
+  source->AddLocalizedString("deviceIdText", IDS_POLICY_DEVICE_ID);
+  source->AddLocalizedString("usernameText",
+                             IDS_POLICY_USERNAME);
+  source->AddLocalizedString("userIdText", IDS_POLICY_USER_ID);
   source->AddLocalizedString("lastFetchedText", IDS_POLICY_LAST_FETCHED);
   source->AddLocalizedString("fetchIntervalText", IDS_POLICY_FETCH_INTERVAL);
   source->AddLocalizedString("serverStatusText", IDS_POLICY_SERVER_STATUS);
   source->AddLocalizedString("showUnsentPoliciesText",
                              IDS_POLICY_SHOW_UNSENT);
   source->AddLocalizedString("filterPoliciesText", IDS_POLICY_FILTER);
   source->AddLocalizedString("noPoliciesSet",IDS_POLICY_NO_POLICIES_SET);
   source->AddLocalizedString("appliesToTableHeader", IDS_POLICY_APPLIES_TO);
   source->AddLocalizedString("policyLevelTableHeader", IDS_POLICY_LEVEL);
   source->AddLocalizedString("policyNameTableHeader", IDS_POLICY_ENTRY_NAME);
   source->AddLocalizedString("policyValueTableHeader", IDS_POLICY_ENTRY_VALUE);
   source->AddLocalizedString("policyStatusTableHeader",
                              IDS_POLICY_ENTRY_STATUS);
+  source->AddLocalizedString("showMoreText", IDS_POLICY_SHOW_MORE);
+  source->AddLocalizedString("hideText", IDS_POLICY_HIDE);
   source->set_json_path("strings.js");
 
   // Add required resources.
   source->add_resource_path("policy.css", IDR_POLICY_CSS);
   source->add_resource_path("policy.js", IDR_POLICY_JS);
   source->set_default_resource(IDR_POLICY_HTML);
 
   return source;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // PolicyUIHandler
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 PolicyUIHandler::PolicyUIHandler() {
   policy::ConfigurationPolicyReader* managed_platform =
       ConfigurationPolicyReader::CreateManagedPlatformPolicyReader();
   policy::ConfigurationPolicyReader* managed_cloud =
       ConfigurationPolicyReader::CreateManagedCloudPolicyReader();
   policy::ConfigurationPolicyReader* recommended_platform =
       ConfigurationPolicyReader::CreateRecommendedPlatformPolicyReader();
   policy::ConfigurationPolicyReader* recommended_cloud =
       ConfigurationPolicyReader::CreateRecommendedCloudPolicyReader();
   policy_status_.reset(new policy::PolicyStatus(managed_platform,
                                                 managed_cloud,
                                                 recommended_platform,
                                                 recommended_cloud));
+  policy_status_->AddObserver(this);
 }
 
 PolicyUIHandler::~PolicyUIHandler() {
+  policy_status_->RemoveObserver(this);
 }
 
 WebUIMessageHandler* PolicyUIHandler::Attach(WebUI* web_ui) {
   return WebUIMessageHandler::Attach(web_ui);
 }
 
 void PolicyUIHandler::RegisterMessages() {
-  web_ui_->RegisterMessageCallback("requestPolicyData",
-      NewCallback(this, &PolicyUIHandler::HandleRequestPolicyData));
+  web_ui_->RegisterMessageCallback("requestData",
+      NewCallback(this, &PolicyUIHandler::HandleRequestData));
+  web_ui_->RegisterMessageCallback("updateFetchTimes",
+      NewCallback(this, &PolicyUIHandler::HandleUpdateFetchTimes));
+  web_ui_->RegisterMessageCallback("fetchPolicy",
+      NewCallback(this, &PolicyUIHandler::HandleFetchPolicy));
 }
 
-void PolicyUIHandler::HandleRequestPolicyData(const ListValue* args) {
+void PolicyUIHandler::OnPolicyValuesChanged() {
+  SendDataToUI(true);
+}
+
+void PolicyUIHandler::HandleRequestData(const ListValue* args) {
+  SendDataToUI(false);
+}
+
+void PolicyUIHandler::HandleUpdateFetchTimes(const ListValue* args) {

[Mattias Nissler (ping if slow), 2011/09/02 11:16:09]

I see that you poll for these from the JS side. I don't think that's necessary,
people will be smart enough to reload the page. Eventually, we can probably also
implement a notification so we can push updates after each reload, but that
probably requires some refactoring of the policy code.

[simo, 2011/09/02 15:32:02]

Since I can't find any time formatting in javascript, I will just not update the
times for now.

+  policy::BrowserPolicyConnector* connector =
+      g_browser_process->browser_policy_connector();
+  policy::CloudPolicySubsystem* device_subsystem =
+      connector->device_cloud_policy_subsystem();
+  policy::CloudPolicySubsystem* user_subsystem =
+      connector->user_cloud_policy_subsystem();
+  DictionaryValue result;
+
+  if (device_subsystem)
+    result.SetString("deviceLastFetchTime",
+                      GetLastFetchTime(device_subsystem));
+  if (user_subsystem)
+    result.SetString("userLastFetchTime",
+                      GetLastFetchTime(user_subsystem));
+
+  web_ui_->CallJavascriptFunction("Policy.returnFetchTimes", result);
+}
+
+void PolicyUIHandler::HandleFetchPolicy(const ListValue* args) {
+  policy::BrowserPolicyConnector* connector =
+      g_browser_process->browser_policy_connector();
+  connector->FetchDevicePolicy();
+  connector->FetchUserPolicy();
+  SendDataToUI(true);
+}
+
+void PolicyUIHandler::SendDataToUI(bool is_policy_update) {
+  DictionaryValue results;
   bool any_policies_sent;
   ListValue* list = policy_status_->GetPolicyStatusList(&any_policies_sent);
-  DictionaryValue results;
   results.Set("policies", list);
   results.SetBoolean("anyPoliciesSet", any_policies_sent);
-  web_ui_->CallJavascriptFunction("Policy.returnPolicyData", results);
+  DictionaryValue* dict = GetStatusData(is_policy_update);
+  results.Set("status", dict);
+
+  if (is_policy_update)
+    web_ui_->CallJavascriptFunction("Policy.updatePolicyData", results);
+  else
+    web_ui_->CallJavascriptFunction("Policy.returnData", results);
+}
+
+DictionaryValue* PolicyUIHandler::GetStatusData(bool is_policy_update) {
+  DictionaryValue* results = new DictionaryValue();
+  policy::BrowserPolicyConnector* connector =
+      g_browser_process->browser_policy_connector();
+
+  policy::CloudPolicySubsystem* device_subsystem =
+      connector->device_cloud_policy_subsystem();
+  policy::CloudPolicySubsystem* user_subsystem =
+      connector->user_cloud_policy_subsystem();
+
+  // If no CloudPolicySubsystem is available, the status section is not
+  // displayed and we can return here.
+  if (!device_subsystem || !user_subsystem) {
+    results->SetBoolean("displayStatusSection", false);
+    return results;
+  } else {
+    results->SetBoolean("displayStatusSection", true);
+  }
+
+  // Get the server status message and the time at which policy was last fetched
+  // for both user and device policy from the appropriate CloudPolicySubsystem.
+  string16 device_status_message =
+      CreateStatusMessageString(device_subsystem->error_details());
+  string16 user_status_message =
+      CreateStatusMessageString(user_subsystem->error_details());
+
+  string16 device_last_fetch_time = GetLastFetchTime(device_subsystem);
+  string16 user_last_fetch_time = GetLastFetchTime(user_subsystem);

[Mattias Nissler (ping if slow), 2011/09/02 11:16:09]

No need for all the local variables, just put the CreateStatusMessageString()
and GetLastFetchTime() calls as second parameter to SetString() below.

[simo, 2011/09/02 15:32:02]

Done.

+
+  results->SetString("deviceStatusMessage", device_status_message);
+  results->SetString("deviceLastFetchTime", device_last_fetch_time);
+  results->SetString("userStatusMessage", user_status_message);
+  results->SetString("userLastFetchTime", user_last_fetch_time);
+
+  // Get device id and user id.
+  const policy::CloudPolicyDataStore* device_data_store =
+      connector->GetDeviceCloudPolicyDataStore();
+  const policy::CloudPolicyDataStore* user_data_store =
+      connector->GetUserCloudPolicyDataStore();
+
+  string16 device_id = device_data_store ?
+      ASCIIToUTF16(device_data_store->device_id()) : string16();
+  string16 user_id = user_data_store ?
+      ASCIIToUTF16(user_data_store->device_id()) : string16();
+  results->SetString("deviceId", device_id);
+  results->SetString("userId", user_id);

[Mattias Nissler (ping if slow), 2011/09/02 11:16:09]

Looks like for the identifiers, you could also introduce a a helper function as
you did for fetch time and status message.

[simo, 2011/09/02 15:32:02]

Done.

+
+  // Get enterprise domain and username (only on ChromeOS).
+#if defined (OS_CHROMEOS)
+  string16 enterprise_domain = ASCIIToUTF16(connector->GetEnterpriseDomain());
+  chromeos::UserManager::User user =
+      chromeos::UserManager::Get()->logged_in_user();
+  string16 username = ASCIIToUTF16(user.email());
+  results->SetString("devicePolicyDomain", enterprise_domain);
+  results->SetString("user", username);

[Mattias Nissler (ping if slow), 2011/09/02 11:16:09]

Again, no need for local variables.

[simo, 2011/09/02 15:32:02]

Done.

+#else
+  results->SetString("devicePolicyDomain", string16());
+  results->SetString("user", string16());
+#endif
+
+  // Get policy fetch interval for both device and user policy.
+  PrefService* prefs = g_browser_process->local_state();
+
+  base::TimeDelta device_fetch_interval = base::TimeDelta::FromMilliseconds(
+      prefs->GetInteger(prefs::kDevicePolicyRefreshRate));

[Mattias Nissler (ping if slow), 2011/09/02 11:16:09]

Another good case for a helper function that wraps getting the time and
formatting it to a string?

[simo, 2011/09/02 15:32:02]

Done.

+  base::TimeDelta user_fetch_interval = base::TimeDelta::FromMilliseconds(
+      prefs->GetInteger(prefs::kUserPolicyRefreshRate));
+
+  results->SetString("deviceFetchInterval",
+      TimeFormat::TimeRemainingShort(device_fetch_interval));
+  results->SetString("userFetchInterval",
+      TimeFormat::TimeRemainingShort(user_fetch_interval));
+
+  return results;
+}
+
+string16 PolicyUIHandler::GetLastFetchTime(
+    policy::CloudPolicySubsystem* subsystem) {
+  policy::CloudPolicyCacheBase* cache_base =
+    subsystem->GetCloudPolicyCacheBase();
+  base::TimeDelta time_delta =
+      base::Time::NowFromSystemTime() - cache_base->last_policy_refresh_time();
+
+  return TimeFormat::TimeElapsed(time_delta);
+}
+
+// static
+string16 PolicyUIHandler::CreateStatusMessageString(
+    CloudPolicySubsystem::ErrorDetails error_details) {
+  static string16 error_to_string[] = { ASCIIToUTF16("OK."),
+                                        ASCIIToUTF16("Network error."),
+                                        ASCIIToUTF16("Network error."),
+                                        ASCIIToUTF16("Bad DMToken."),
+                                        ASCIIToUTF16("Local error."),
+                                        ASCIIToUTF16("Signature mismatch.") };
+  DCHECK(static_cast<size_t>(error_details) < arraysize(error_to_string));
+  return error_to_string[error_details];
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // PolicyUI
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 PolicyUI::PolicyUI(TabContents* contents) : ChromeWebUI(contents) {
   AddMessageHandler((new PolicyUIHandler)->Attach(this));
 
   // Set up the chrome://policy/ source.
   Profile* profile = Profile::FromBrowserContext(contents->browser_context());
   profile->GetChromeURLDataManager()->AddDataSource(CreatePolicyUIHTMLSource());
 }
 
 PolicyUI::~PolicyUI() {
 }