Allow PolicyLoadStatusSample to override reporting method

components/policy/core/common/preg_parser.cc

 // Copyright (c) 2013 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/preg_parser.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 276 matching lines @@
 
 namespace policy {
 namespace preg_parser {
 
 const char kPRegFileHeader[8] = {'P',    'R',    'e',    'g',
                                  '\x01', '\x00', '\x00', '\x00'};
 
 bool ReadFile(const base::FilePath& file_path,
               const base::string16& root,
               RegistryDict* dict,
-              PolicyLoadStatusSample* status_sample) {
+              PolicyLoadStatusSampler* status) {
   base::MemoryMappedFile mapped_file;
   if (!mapped_file.Initialize(file_path) || !mapped_file.IsValid()) {
     PLOG(ERROR) << "Failed to map " << file_path.value();
-    status_sample->Add(POLICY_LOAD_STATUS_READ_ERROR);
+    status->Add(POLICY_LOAD_STATUS_READ_ERROR);
     return false;
   }
 
-  PolicyLoadStatus status = POLICY_LOAD_STATUS_SIZE;
-  bool res = ReadDataInternal(
-      mapped_file.data(), mapped_file.length(), root, dict, &status,
+  return ReadDataInternal(
+      mapped_file.data(), mapped_file.length(), root, dict, status,
       base::StringPrintf("file '%s'", file_path.value().c_str()));
-  if (!res) {
-    DCHECK(status != POLICY_LOAD_STATUS_SIZE);
-    status_sample->Add(status);
-  }
-  return res;
 }
 
 POLICY_EXPORT bool ReadDataInternal(const uint8_t* preg_data,
                                     size_t preg_data_size,
                                     const base::string16& root,
                                     RegistryDict* dict,
-                                    PolicyLoadStatus* status,
+                                    PolicyLoadStatusSampler* status,
                                     const std::string& debug_name) {
   DCHECK(status);
   DCHECK(root.empty() || root.back() != kRegistryPathSeparator[0]);
 
   // Check data size.
   if (preg_data_size > kMaxPRegFileSize) {
     LOG(ERROR) << "PReg " << debug_name << " too large: " << preg_data_size;
-    *status = POLICY_LOAD_STATUS_TOO_BIG;
+    status->Add(POLICY_LOAD_STATUS_TOO_BIG);
     return false;
   }
 
   // Check the header.
   const int kHeaderSize = arraysize(kPRegFileHeader);
   if (!preg_data || preg_data_size < kHeaderSize ||
       memcmp(kPRegFileHeader, preg_data, kHeaderSize) != 0) {
     LOG(ERROR) << "Bad PReg " << debug_name;
-    *status = POLICY_LOAD_STATUS_PARSE_ERROR;
+    status->Add(POLICY_LOAD_STATUS_PARSE_ERROR);
     return false;
   }
 
   // Parse data, which is expected to be UCS-2 and little-endian. The latter I
   // couldn't find documentation on, but the example I saw were all
   // little-endian. It'd be interesting to check on big-endian hardware.
   const uint8_t* cursor = preg_data + kHeaderSize;
   const uint8_t* end = preg_data + preg_data_size;
   while (true) {
     if (cursor == end)
@@ skipping 43 matching lines @@
     if (current != kDelimBracketClose)
       break;
 
     // Process the record if it is within the |root| subtree.
     if (KeyRootEquals(key_name, root))
       HandleRecord(key_name.substr(root.size()), value, type, data, dict);
   }
 
   LOG(ERROR) << "Error parsing PReg " << debug_name << " at offset "
              << (reinterpret_cast<const uint8_t*>(cursor - 1) - preg_data);
-  *status = POLICY_LOAD_STATUS_PARSE_ERROR;
+  status->Add(POLICY_LOAD_STATUS_PARSE_ERROR);
   return false;
 }
 
 }  // namespace preg_parser
 }  // namespace policy