Allow PolicyLoadStatusSample to override reporting method

components/policy/core/common/policy_loader_win.cc

 // Copyright (c) 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 "components/policy/core/common/policy_loader_win.h"
 
-#include <windows.h>
 #include <ntdsapi.h>  // For Ds[Un]Bind
 #include <rpc.h>      // For struct GUID
 #include <shlwapi.h>  // For PathIsUNC()
 #include <stddef.h>
 #include <userenv.h>  // For GPO functions
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 45 matching lines @@
 
 // List of policies that are considered only if the user is part of a AD domain.
 // Please document any new additions in policy_templates.json!
 const char* kInsecurePolicies[] = {
     key::kMetricsReportingEnabled, key::kDefaultSearchProviderEnabled,
     key::kHomepageIsNewTabPage,    key::kHomepageLocation,
     key::kNewTabPageLocation,      key::kRestoreOnStartup,
     key::kRestoreOnStartupURLs};
 
 #pragma warning(push)
-#pragma warning(disable: 4068)  // unknown pragmas
+#pragma warning(disable : 4068)  // unknown pragmas
 // TODO(dcheng): Remove pragma once http://llvm.org/PR24007 is fixed.
 #pragma clang diagnostic ignored "-Wmissing-braces"
 // The GUID of the registry settings group policy extension.
 GUID kRegistrySettingsCSEGUID = REGISTRY_EXTENSION_GUID;
 #pragma warning(pop)
 
 // The list of possible errors that can occur while collecting information about
 // the current enterprise environment.
 // This enum is used to define the buckets for an enumerated UMA histogram.
 // Hence,
@@ skipping 41 matching lines @@
         invalid_policies++;
       }
 
       filtered_values->AppendString(entry);
     }
     if (invalid_policies) {
       PolicyMap::Entry filtered_entry = map_entry->DeepCopy();
       filtered_entry.value = std::move(filtered_values);
       policy->Set(key::kExtensionInstallForcelist, std::move(filtered_entry));
 
-      const PolicyDetails* details = GetChromePolicyDetails(
-          key::kExtensionInstallForcelist);
+      const PolicyDetails* details =
+          GetChromePolicyDetails(key::kExtensionInstallForcelist);
       UMA_HISTOGRAM_SPARSE_SLOWLY("EnterpriseCheck.InvalidPolicies",
                                   details->id);
     }
   }
 
   for (size_t i = 0; i < arraysize(kInsecurePolicies); ++i) {
     if (policy->Get(kInsecurePolicies[i])) {
       // TODO(pastarmovj): Surface this issue in the about:policy page.
       policy->Erase(kInsecurePolicies[i]);
       invalid_policies++;
       const PolicyDetails* details =
           GetChromePolicyDetails(kInsecurePolicies[i]);
       UMA_HISTOGRAM_SPARSE_SLOWLY("EnterpriseCheck.InvalidPolicies",
                                   details->id);
     }
   }
 
   UMA_HISTOGRAM_COUNTS("EnterpriseCheck.InvalidPoliciesDetected",
                        invalid_policies);
 }
 
 // A helper class encapsulating run-time-linked function calls to Wow64 APIs.
 class Wow64Functions {
  public:
   Wow64Functions()
-    : kernel32_lib_(base::FilePath(L"kernel32")),
-      is_wow_64_process_(NULL),
-      wow_64_disable_wow_64_fs_redirection_(NULL),
-      wow_64_revert_wow_64_fs_redirection_(NULL) {
+      : kernel32_lib_(base::FilePath(L"kernel32")),
+        is_wow_64_process_(NULL),
+        wow_64_disable_wow_64_fs_redirection_(NULL),
+        wow_64_revert_wow_64_fs_redirection_(NULL) {
     if (kernel32_lib_.is_valid()) {
       is_wow_64_process_ = reinterpret_cast<IsWow64Process>(
           kernel32_lib_.GetFunctionPointer("IsWow64Process"));
       wow_64_disable_wow_64_fs_redirection_ =
           reinterpret_cast<Wow64DisableWow64FSRedirection>(
               kernel32_lib_.GetFunctionPointer(
                   "Wow64DisableWow64FsRedirection"));
       wow_64_revert_wow_64_fs_redirection_ =
           reinterpret_cast<Wow64RevertWow64FSRedirection>(
               kernel32_lib_.GetFunctionPointer(
                   "Wow64RevertWow64FsRedirection"));
     }
   }
 
   bool is_valid() {
-    return is_wow_64_process_ &&
-        wow_64_disable_wow_64_fs_redirection_ &&
-        wow_64_revert_wow_64_fs_redirection_;
+    return is_wow_64_process_ && wow_64_disable_wow_64_fs_redirection_ &&
+           wow_64_revert_wow_64_fs_redirection_;
   }
 
   bool IsWow64() {
     BOOL result = 0;
     if (!is_wow_64_process_(GetCurrentProcess(), &result))
       PLOG(WARNING) << "IsWow64ProcFailed";
     return !!result;
   }
 
   bool DisableFsRedirection(PVOID* previous_state) {
     return !!wow_64_disable_wow_64_fs_redirection_(previous_state);
   }
 
   bool RevertFsRedirection(PVOID previous_state) {
     return !!wow_64_revert_wow_64_fs_redirection_(previous_state);
   }
 
  private:
-  typedef BOOL (WINAPI* IsWow64Process)(HANDLE, PBOOL);
-  typedef BOOL (WINAPI* Wow64DisableWow64FSRedirection)(PVOID*);
-  typedef BOOL (WINAPI* Wow64RevertWow64FSRedirection)(PVOID);
+  typedef BOOL(WINAPI* IsWow64Process)(HANDLE, PBOOL);
+  typedef BOOL(WINAPI* Wow64DisableWow64FSRedirection)(PVOID*);
+  typedef BOOL(WINAPI* Wow64RevertWow64FSRedirection)(PVOID);
 
   base::ScopedNativeLibrary kernel32_lib_;
 
   IsWow64Process is_wow_64_process_;
   Wow64DisableWow64FSRedirection wow_64_disable_wow_64_fs_redirection_;
   Wow64RevertWow64FSRedirection wow_64_revert_wow_64_fs_redirection_;
 
   DISALLOW_COPY_AND_ASSIGN(Wow64Functions);
 };
 
 // Global Wow64Function instance used by ScopedDisableWow64Redirection below.
 static base::LazyInstance<Wow64Functions>::DestructorAtExit g_wow_64_functions =
     LAZY_INSTANCE_INITIALIZER;
 
 // Scoper that switches off Wow64 File System Redirection during its lifetime.
 class ScopedDisableWow64Redirection {
  public:
-  ScopedDisableWow64Redirection()
-    : active_(false),
-      previous_state_(NULL) {
+  ScopedDisableWow64Redirection() : active_(false), previous_state_(NULL) {
     Wow64Functions* wow64 = g_wow_64_functions.Pointer();
     if (wow64->is_valid() && wow64->IsWow64()) {
       if (wow64->DisableFsRedirection(&previous_state_))
         active_ = true;
       else
         PLOG(WARNING) << "Wow64DisableWow64FSRedirection";
     }
   }
 
   ~ScopedDisableWow64Redirection() {
@@ skipping 130 matching lines @@
   // Reset the watches BEFORE reading the individual policies to avoid
   // missing a change notification.
   if (is_initialized_)
     SetupWatches();
 
   // Policy scope and corresponding hive.
   static const struct {
     PolicyScope scope;
     HKEY hive;
   } kScopes[] = {
-    { POLICY_SCOPE_MACHINE, HKEY_LOCAL_MACHINE },
-    { POLICY_SCOPE_USER,    HKEY_CURRENT_USER  },
+      {POLICY_SCOPE_MACHINE, HKEY_LOCAL_MACHINE},
+      {POLICY_SCOPE_USER, HKEY_CURRENT_USER},
   };
 
   bool honor_policies = ShouldHonorPolicies();
   VLOG(1) << "Reading policy from the registry is "
           << (honor_policies ? "enabled." : "disabled.");
 
   // Load policy data for the different scopes/levels and merge them.
   std::unique_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;
+    PolicyLoadStatusUmaReporter status;
     RegistryDict gpo_dict;
 
     // Note: GPO rules mandate a call to EnterCriticalPolicySection() here, and
     // a matching LeaveCriticalPolicySection() call below after the
     // ReadPolicyFromGPO() block. Unfortunately, the policy mutex may be
     // unavailable for extended periods of time, and there are reports of this
     // happening in the wild: http://crbug.com/265862.
     //
     // Blocking for minutes is neither acceptable for Chrome startup, nor on
     // the FILE thread on which this code runs in steady state. Given that
@@ skipping 27 matching lines @@
     // Load 3rd-party policy.
     if (third_party_dict)
       Load3rdPartyPolicy(third_party_dict.get(), scope, bundle.get());
   }
 
   return bundle;
 }
 
 bool PolicyLoaderWin::ReadPRegFile(const base::FilePath& preg_file,
                                    RegistryDict* policy,
-                                   PolicyLoadStatusSample* status) {
+                                   PolicyLoadStatusSampler* 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 (base::PathExists(preg_file)) {
     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() && base::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,
                                     RegistryDict* policy,
-                                    PolicyLoadStatusSample* status) {
+                                    PolicyLoadStatusSampler* status) {
   RegistryDict parsed_policy;
   RegistryDict forced_policy;
-  for (GROUP_POLICY_OBJECT* policy_object = policy_object_list;
-       policy_object; policy_object = policy_object->pNext) {
+  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;
     }
@@ skipping 23 matching lines @@
   // this, use only one dict and call ReadPRegFile in the proper order (forced
   // last). See crbug.com/659979.
   parsed_policy.Merge(forced_policy);
   policy->Swap(&parsed_policy);
 
   return true;
 }
 
 bool PolicyLoaderWin::ReadPolicyFromGPO(PolicyScope scope,
                                         RegistryDict* policy,
-                                        PolicyLoadStatusSample* status) {
+                                        PolicyLoadStatusSampler* 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) {
+  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 = true;
   if (policy_object_list) {
     result = LoadGPOPolicy(scope, policy_object_list, policy, status);
     if (!gpo_provider_->FreeGPOList(policy_object_list))
       LOG(WARNING) << "FreeGPOList";
@@ skipping 17 matching lines @@
 }
 
 void PolicyLoaderWin::Load3rdPartyPolicy(const RegistryDict* gpo_dict,
                                          PolicyScope scope,
                                          PolicyBundle* bundle) {
   // Map of known 3rd party policy domain name to their enum values.
   static const struct {
     const char* name;
     PolicyDomain domain;
   } k3rdPartyDomains[] = {
-    { "extensions", POLICY_DOMAIN_EXTENSIONS },
+      {"extensions", POLICY_DOMAIN_EXTENSIONS},
   };
 
   // Policy level and corresponding path.
   static const struct {
     PolicyLevel level;
     const char* path;
   } kLevels[] = {
-    { POLICY_LEVEL_MANDATORY,   kKeyMandatory   },
-    { POLICY_LEVEL_RECOMMENDED, kKeyRecommended },
+      {POLICY_LEVEL_MANDATORY, kKeyMandatory},
+      {POLICY_LEVEL_RECOMMENDED, kKeyRecommended},
   };
 
   for (size_t i = 0; i < arraysize(k3rdPartyDomains); i++) {
     const char* name = k3rdPartyDomains[i].name;
     const PolicyDomain domain = k3rdPartyDomains[i].domain;
     const RegistryDict* domain_dict = gpo_dict->GetKey(name);
     if (!domain_dict)
       continue;
 
     for (RegistryDict::KeyMap::const_iterator component(
              domain_dict->keys().begin());
-         component != domain_dict->keys().end();
-         ++component) {
+         component != domain_dict->keys().end(); ++component) {
       const PolicyNamespace policy_namespace(domain, component->first);
 
       const Schema* schema_from_map = schema_map()->GetSchema(policy_namespace);
       if (!schema_from_map) {
         // This extension isn't installed or doesn't support policies.
         continue;
       }
       Schema schema = *schema_from_map;
 
       // Parse policy.
@@ skipping 25 matching lines @@
       !machine_policy_watcher_.StartWatchingOnce(
           machine_policy_changed_event_.handle(), this)) {
     DLOG(WARNING) << "Failed to start watch for machine policy change event";
     machine_policy_watcher_failed_ = true;
   }
 }
 
 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;
+      << "unexpected object signaled policy reload, obj = " << std::showbase
+      << std::hex << object;
   Reload(false);
 }
 
 }  // namespace policy