Add standard policy provider tests for PReg policy reading.

chrome/browser/policy/preg_parser_win.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 "chrome/browser/policy/preg_parser_win.h"
 
+#include <windows.h>
+
 #include <algorithm>
 #include <iterator>
-
-#include <windows.h>
+#include <vector>
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/sys_byteorder.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 
 namespace policy {
 namespace preg_parser {
 
-// The magic header in PReg files: ASCII "PReg" + version (0x0001).
-const char kPolicyRegistryFileHeader[] = "PReg\x01\x00\x00\x00";
+const char kPRegFileHeader[8] =
+    { 'P', 'R', 'e', 'g', '\x01', '\x00', '\x00', '\x00' };
 
 // Maximum PReg file size we're willing to accept.
 const int64 kMaxPRegFileSize = 1024 * 1024 * 16;
 
 // Constants for PReg file delimiters.
 const char16 kDelimBracketOpen = L'[';
 const char16 kDelimBracketClose = L']';
 const char16 kDelimSemicolon = L';';
 
 // Registry path separator.
@@ skipping 183 matching lines @@
     return false;
   }
 
   if (mapped_file.length() > kMaxPRegFileSize) {
     LOG(ERROR) << "PReg file " << file_path.value() << " too large: "
                << mapped_file.length();
     return false;
   }
 
   // Check the header.
-  const int kHeaderSize = arraysize(kPolicyRegistryFileHeader) - 1;
+  const int kHeaderSize = arraysize(kPRegFileHeader);
   if (mapped_file.length() < kHeaderSize ||
-      memcmp(kPolicyRegistryFileHeader, mapped_file.data(), kHeaderSize) != 0) {
+      memcmp(kPRegFileHeader, mapped_file.data(), kHeaderSize) != 0) {
     LOG(ERROR) << "Bad policy file " << file_path.value();
     return false;
   }
 
   // Parse file contents, which is 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* cursor = mapped_file.data() + kHeaderSize;
   const uint8* end = mapped_file.data() + mapped_file.length();
   while (true) {
@@ skipping 49 matching lines @@
       HandleRecord(key_name.substr(root.size()), value, type, data, dict);
   }
 
   LOG(ERROR) << "Error parsing " << file_path.value() << " at offset "
              << reinterpret_cast<const uint8*>(cursor - 1) - mapped_file.data();
   return false;
 }
 
 }  // namespace preg_parser
 }  // namespace policy