Chromoting needs null GPO provider in PolicyLoaderWin.

components/policy/core/common/policy_loader_win_unittest.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 "components/policy/core/common/policy_loader_win.h"
 
 #include <windows.h>
 #include <userenv.h>
 
 #include <algorithm>
@@ skipping 694 matching lines @@
   virtual void SetUp() override {
     base::win::SetDomainStateForTesting(false);
     PolicyTestBase::SetUp();
 
     ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &test_data_dir_));
     test_data_dir_ = test_data_dir_.AppendASCII("chrome")
                                    .AppendASCII("test")
                                    .AppendASCII("data")
                                    .AppendASCII("policy")
                                    .AppendASCII("gpo");
+
+    gpo_list_provider_ = this;
   }
 
   // AppliedGPOListProvider:
   virtual DWORD GetAppliedGPOList(DWORD flags,
                                   LPCTSTR machine_name,
                                   PSID sid_user,
                                   GUID* extension_guid,
                                   PGROUP_POLICY_OBJECT* gpo_list) override {
     *gpo_list = gpo_list_;
     return gpo_list_status_;
   }
   virtual BOOL FreeGPOList(PGROUP_POLICY_OBJECT gpo_list) override {
     return TRUE;
   }
 
   void InitGPO(GROUP_POLICY_OBJECT* gpo,
                DWORD options,
                const base::FilePath& path,
                GROUP_POLICY_OBJECT* next,
                GROUP_POLICY_OBJECT* prev) {
     memset(gpo, 0, sizeof(GROUP_POLICY_OBJECT));
     gpo->dwOptions = options;
     gpo->lpFileSysPath = const_cast<wchar_t*>(path.value().c_str());
     gpo->pNext = next;
     gpo->pPrev = prev;
   }
 
   bool Matches(const PolicyBundle& expected) {
-    PolicyLoaderWin loader(loop_.message_loop_proxy(), kTestPolicyKey, this);
+    PolicyLoaderWin loader(loop_.message_loop_proxy(), kTestPolicyKey,
+                           gpo_list_provider_);
     scoped_ptr<PolicyBundle> loaded(
         loader.InitialLoad(schema_registry_.schema_map()));
     return loaded->Equals(expected);
   }
 
   void InstallRegistrySentinel() {
     RegKey hklm_key(HKEY_CURRENT_USER, kTestPolicyKey, KEY_ALL_ACCESS);
     ASSERT_TRUE(hklm_key.Valid());
     hklm_key.WriteValue(
         UTF8ToUTF16(test_keys::kKeyString).c_str(),
@@ skipping 22 matching lines @@
     expected.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
         .LoadFrom(&expected_policy, POLICY_LEVEL_MANDATORY,
                   POLICY_SCOPE_MACHINE);
     return Matches(expected);
   }
 
   ScopedGroupPolicyRegistrySandbox registry_sandbox_;
   PGROUP_POLICY_OBJECT gpo_list_;
   DWORD gpo_list_status_;
   base::FilePath test_data_dir_;
+  AppliedGPOListProvider* gpo_list_provider_;
 };
 
 const base::char16 PolicyLoaderWinTest::kTestPolicyKey[] =
     L"SOFTWARE\\Policies\\Chromium";
 
 TEST_F(PolicyLoaderWinTest, HKLMOverHKCU) {
   RegKey hklm_key(HKEY_LOCAL_MACHINE, kTestPolicyKey, KEY_ALL_ACCESS);
   ASSERT_TRUE(hklm_key.Valid());
   hklm_key.WriteValue(UTF8ToUTF16(test_keys::kKeyString).c_str(),
                       UTF8ToUTF16("hklm").c_str());
@@ skipping 244 matching lines @@
 
 TEST_F(PolicyLoaderWinTest, AppliedPolicyInDomain) {
   base::win::SetDomainStateForTesting(true);
   InstallRegistrySentinel();
   base::FilePath gpo_dir(test_data_dir_.AppendASCII("empty"));
   GROUP_POLICY_OBJECT gpo;
   InitGPO(&gpo, 0, gpo_dir, NULL, NULL);
   gpo_list_ = &gpo;
   gpo_list_status_ = ERROR_SUCCESS;
 
-  PolicyBundle empty;
   EXPECT_TRUE(MatchesRegistrySentinel());
 }
 
+TEST_F(PolicyLoaderWinTest, GpoProviderNotSpecified) {
+  base::win::SetDomainStateForTesting(false);
+  InstallRegistrySentinel();
+  base::FilePath gpo_dir(test_data_dir_.AppendASCII("empty"));
+  GROUP_POLICY_OBJECT gpo;
+  InitGPO(&gpo, 0, gpo_dir, NULL, NULL);
+  gpo_list_ = &gpo;
+  gpo_list_status_ = ERROR_SUCCESS;
+  gpo_list_provider_ = nullptr;
+
+  EXPECT_TRUE(MatchesRegistrySentinel());
+}
+
 TEST_F(PolicyLoaderWinTest, AppliedPolicyNonExistingFile) {
   InstallRegistrySentinel();
   GROUP_POLICY_OBJECT gpo;
   InitGPO(&gpo, 0, test_data_dir_, NULL, NULL);
   gpo_list_ = &gpo;
   gpo_list_status_ = ERROR_SUCCESS;
 
   EXPECT_TRUE(MatchesRegistrySentinel());
 }
 
@@ skipping 143 matching lines @@
   PolicyMap& expected_policy = expected.Get(ns);
   expected_policy.Set("alternative_browser_path",
                       POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                       new base::StringValue("c:\\legacy\\browser.exe"), NULL);
   expected_policy.Set("url_list", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                       list.DeepCopy(), NULL);
   EXPECT_TRUE(Matches(expected));
 }
 
 }  // namespace policy