Add UMA histograms for policy loading.

chrome/browser/policy/policy_loader_win.cc

 // Copyright (c) 2012 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/policy_loader_win.h"
 
 #include <rpc.h>      // For struct GUID
 #include <shlwapi.h>  // For PathIsUNC()
 #include <userenv.h>  // For GPO functions
 #include <windows.h>
@@ skipping 13 matching lines @@
 #include "base/logging.h"
 #include "base/scoped_native_library.h"
 #include "base/stl_util.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/registry.h"
 #include "chrome/browser/policy/policy_bundle.h"
+#include "chrome/browser/policy/policy_load_status.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "chrome/browser/policy/preg_parser_win.h"
 #include "chrome/common/json_schema/json_schema_constants.h"
 #include "policy/policy_constants.h"
 
 namespace schema = json_schema_constants;
 
 using base::win::RegKey;
 using base::win::RegistryKeyIterator;
 using base::win::RegistryValueIterator;
@@ skipping 459 matching lines @@
     { POLICY_SCOPE_MACHINE, HKEY_LOCAL_MACHINE },
     { POLICY_SCOPE_USER,    HKEY_CURRENT_USER  },
   };
 
   // Load policy data for the different scopes/levels and merge them.
   scoped_ptr<PolicyBundle> bundle(new PolicyBundle());
   PolicyMap* chrome_policy =
       &bundle->Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()));
   for (size_t i = 0; i < arraysize(kScopes); ++i) {
     PolicyScope scope = kScopes[i].scope;
+    PolicyLoadStatusSample status(scope, -1);
     base::DictionaryValue gpo_dict;
 
     HANDLE policy_lock =
         EnterCriticalPolicySection(scope == POLICY_SCOPE_MACHINE);
     if (policy_lock == NULL)
       PLOG(ERROR) << "EnterCriticalPolicySection";
 
-    if (!ReadPolicyFromGPO(scope, &gpo_dict)) {
+    if (!ReadPolicyFromGPO(scope, &gpo_dict, &status)) {
       VLOG(1) << "Failed to read GPO files for " << scope
               << " falling back to registry.";
       ReadRegistry(kScopes[i].hive, chrome_policy_key_, &gpo_dict);

[Joao da Silva, 2013/04/16 17:31:04]

No sampling for this case?

[Mattias Nissler (ping if slow), 2013/04/16 18:51:14]

It's all good! :)

Assuming ReadPolicyFromGPO samples all its branches, we don't need anything
here.

     }
 
     if (!LeaveCriticalPolicySection(policy_lock))
       PLOG(ERROR) << "LeaveCriticalPolicySection";
 
     // Remove special-cased entries from the GPO dictionary.
     base::DictionaryValue* temp_dict = NULL;
     scoped_ptr<base::DictionaryValue> recommended_dict(
         RemoveDict(&gpo_dict, kKeyRecommended));
     scoped_ptr<base::DictionaryValue> third_party_dict(
@@ skipping 31 matching lines @@
     }
     properties->SetWithoutPathExpansion(e->name, entry_schema.release());
   }
   chrome_policy_schema_.SetStringWithoutPathExpansion(
       json_schema_constants::kType, json_schema_constants::kObject);
   chrome_policy_schema_.SetWithoutPathExpansion(
       json_schema_constants::kProperties, properties.release());
 }
 
 bool PolicyLoaderWin::ReadPRegFile(const base::FilePath& preg_file,
-                                   base::DictionaryValue* policy) {
+                                   base::DictionaryValue* policy,
+                                   PolicyLoadStatusSample* status) {
   // The following deals with the minor annoyance that Wow64 FS redirection
   // might need to be turned off: This is the case if running as a 32-bit
   // process on a 64-bit system, in which case Wow64 FS redirection redirects
   // access to the %WINDIR%/System32/GroupPolicy directory to
   // %WINDIR%/SysWOW64/GroupPolicy, but the file is actually in the
   // system-native directory.
   if (file_util::PathExists(preg_file)) {
-    return preg_parser::ReadFile(preg_file, chrome_policy_key_, policy);
+    return preg_parser::ReadFile(preg_file, chrome_policy_key_, policy, status);
   } else {
     // Try with redirection switched off.
     ScopedDisableWow64Redirection redirection_disable;
-    if (redirection_disable.is_active() && file_util::PathExists(preg_file))
-      return preg_parser::ReadFile(preg_file, chrome_policy_key_, policy);
+    if (redirection_disable.is_active() && file_util::PathExists(preg_file)) {
+      status->Add(POLICY_LOAD_STATUS_WOW64_REDIRECTION_DISABLED);
+      return preg_parser::ReadFile(preg_file, chrome_policy_key_, policy,
+                                   status);
+    }
   }
 
   // Report the error.
   LOG(ERROR) << "PReg file doesn't exist: " << preg_file.value();
+  status->Add(POLICY_LOAD_STATUS_MISSING);
   return false;
 }
 
 bool PolicyLoaderWin::LoadGPOPolicy(PolicyScope scope,
                                     PGROUP_POLICY_OBJECT policy_object_list,
-                                    base::DictionaryValue* policy) {
+                                    base::DictionaryValue* policy,
+                                    PolicyLoadStatusSample* status) {
   base::DictionaryValue parsed_policy;
   base::DictionaryValue forced_policy;
   for (GROUP_POLICY_OBJECT* policy_object = policy_object_list;
        policy_object; policy_object = policy_object->pNext) {
     if (policy_object->dwOptions & GPO_FLAG_DISABLE)
       continue;
 
     if (PathIsUNC(policy_object->lpFileSysPath)) {
       // UNC path: Assume this is an AD-managed machine, which updates the
       // registry via GPO's standard registry CSE periodically. Fall back to
       // reading from the registry in this case.
+      status->Add(POLICY_LOAD_STATUS_INACCCESSIBLE);
       return false;
     }
 
     base::FilePath preg_file_path(
         base::FilePath(policy_object->lpFileSysPath).Append(kPRegFileName));
     if (policy_object->dwOptions & GPO_FLAG_FORCE) {
       base::DictionaryValue new_forced_policy;
-      if (!ReadPRegFile(preg_file_path, &new_forced_policy))
+      if (!ReadPRegFile(preg_file_path, &new_forced_policy, status))
         return false;
 
       // Merge with existing forced policy, giving precedence to the existing
       // forced policy.
       new_forced_policy.MergeDictionary(&forced_policy);
       forced_policy.Swap(&new_forced_policy);
     } else {
-      if (!ReadPRegFile(preg_file_path, &parsed_policy))
+      if (!ReadPRegFile(preg_file_path, &parsed_policy, status))
         return false;
     }
   }
 
   // Merge, give precedence to forced policy.
   parsed_policy.MergeDictionary(&forced_policy);
   policy->Swap(&parsed_policy);
 
   return true;
 }
 
 
 bool PolicyLoaderWin::ReadPolicyFromGPO(PolicyScope scope,
-                                        base::DictionaryValue* policy) {
+                                        base::DictionaryValue* policy,
+                                        PolicyLoadStatusSample* status) {
   PGROUP_POLICY_OBJECT policy_object_list = NULL;
   DWORD flags = scope == POLICY_SCOPE_MACHINE ? GPO_LIST_FLAG_MACHINE : 0;
   if (gpo_provider_->GetAppliedGPOList(
           flags, NULL, NULL, &kRegistrySettingsCSEGUID,
           &policy_object_list) != ERROR_SUCCESS) {
     PLOG(ERROR) << "GetAppliedGPOList scope " << scope;
+    status->Add(POLICY_LOAD_STATUS_QUERY_FAILED);
     return false;
   }
 
-  bool result = LoadGPOPolicy(scope, policy_object_list, policy);
-  if (!gpo_provider_->FreeGPOList(policy_object_list))
-    LOG(WARNING) << "FreeGPOList";
+  bool result = true;
+  if (policy_object_list) {
+    result = LoadGPOPolicy(scope, policy_object_list, policy, status);
+    if (!gpo_provider_->FreeGPOList(policy_object_list))
+      LOG(WARNING) << "FreeGPOList";
+  } else {
+    status->Add(POLICY_LOAD_STATUS_NO_POLICY);
+  }
 
   return result;
 }
 
 void PolicyLoaderWin::LoadChromePolicy(const base::DictionaryValue* gpo_dict,
                                        PolicyLevel level,
                                        PolicyScope scope,
                                        PolicyMap* chrome_policy_map) {
   PolicyMap policy;
   ParsePolicy(gpo_dict, level, scope, &chrome_policy_schema_, &policy);
@@ skipping 89 matching lines @@
 
 void PolicyLoaderWin::OnObjectSignaled(HANDLE object) {
   DCHECK(object == user_policy_changed_event_.handle() ||
          object == machine_policy_changed_event_.handle())
       << "unexpected object signaled policy reload, obj = "
       << std::showbase << std::hex << object;
   Reload(false);
 }
 
 }  // namespace policy