Removed the PolicyDefinitionList.

chrome/browser/chromeos/policy/cloud_external_data_manager_base_unittest.cc

 // Copyright 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/chromeos/policy/cloud_external_data_manager_base.h"
 
 #include <map>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
 #include "base/sha1.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/policy/cloud_external_data_store.h"
 #include "chrome/browser/policy/cloud/mock_cloud_policy_store.h"
 #include "chrome/browser/policy/cloud/resource_cache.h"
 #include "chrome/browser/policy/external_data_fetcher.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "chrome/browser/policy/policy_types.h"
+#include "chrome/browser/policy/test/policy_test_utils.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_status.h"
 #include "net/url_request/url_request_test_util.h"
-#include "policy/policy_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace policy {
 
 namespace {
 
 // A string policy.
 const char kStringPolicy[] = "StringPolicy";
 // A policy that may reference up to 10 bytes of external data.
 const char k10BytePolicy[] = "10BytePolicy";
 // A policy that may reference up to 20 bytes of external data.
 const char k20BytePolicy[] = "20BytePolicy";
 // A nonexistent policy.
 const char kUnknownPolicy[] = "UnknownPolicy";
 
 const char k10BytePolicyURL[] = "http://localhost/10_bytes";
 const char k20BytePolicyURL[] = "http://localhost/20_bytes";
 
 const char k10ByteData[] = "10 bytes..";
 const char k20ByteData[] = "20 bytes............";
 
-const PolicyDefinitionList::Entry kPolicyDefinitionListEntries[] = {
-  { kStringPolicy, base::Value::TYPE_STRING, false, 1, 0 },
-  { k10BytePolicy, base::Value::TYPE_DICTIONARY, false, 2, 10 },
-  { k20BytePolicy, base::Value::TYPE_DICTIONARY, false, 3, 20 },
-};
-
-const PolicyDefinitionList kPolicyDefinitionList = {
-  kPolicyDefinitionListEntries,
-  kPolicyDefinitionListEntries + arraysize(kPolicyDefinitionListEntries),
+const PolicyDetails kPolicyDetails[] = {
+//  is_deprecated  is_device_policy  id    max_external_data_size
+  { false,         false,             1,                        0 },
+  { false,         false,             2,                       10 },
+  { false,         false,             3,                       20 },
 };
 
 const char kCacheKey[] = "data";
 
 // A variant of net::FakeURLFetcherFactory that makes it an error to request a
 // fetcher for an unknown URL.
 class FakeURLFetcherFactory : public net::FakeURLFetcherFactory {
  public:
   FakeURLFetcherFactory();
   virtual ~FakeURLFetcherFactory();
@@ skipping 58 matching lines @@
   base::MessageLoop message_loop_;
   base::ScopedTempDir temp_dir_;
   scoped_ptr<ResourceCache> resource_cache_;
   MockCloudPolicyStore cloud_policy_store_;
   scoped_refptr<net::TestURLRequestContextGetter> request_content_getter_;
   FakeURLFetcherFactory fetcher_factory_;
 
   scoped_ptr<CloudExternalDataManagerBase> external_data_manager_;
 
   std::map<int, std::string*> callback_data_;
+  PolicyDetailsMap policy_details_;
 
   DISALLOW_COPY_AND_ASSIGN(CloudExternalDataManagerBaseTest);
 };
 
 CloudExternalDataManagerBaseTest::CloudExternalDataManagerBaseTest() {
 }
 
 void CloudExternalDataManagerBaseTest::SetUp() {
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   resource_cache_.reset(new ResourceCache(temp_dir_.path(),
@@ skipping 11 matching lines @@
       k10BytePolicy,
       ConstructMetadata(k10BytePolicyURL, base::SHA1HashString(k10ByteData)));
   // Make |k20BytePolicy| reference 20 bytes of external data.
   SetExternalDataReference(
       k20BytePolicy,
       ConstructMetadata(k20BytePolicyURL, base::SHA1HashString(k20ByteData)));
   cloud_policy_store_.NotifyStoreLoaded();
 
   request_content_getter_ = new net::TestURLRequestContextGetter(
       base::MessageLoopProxy::current());
+
+  policy_details_.SetDetails(kStringPolicy, &kPolicyDetails[0]);
+  policy_details_.SetDetails(k10BytePolicy, &kPolicyDetails[1]);
+  policy_details_.SetDetails(k20BytePolicy, &kPolicyDetails[2]);
 }
 
 void CloudExternalDataManagerBaseTest::TearDown() {
   external_data_manager_.reset();
   base::RunLoop().RunUntilIdle();
   ResetCallbackData();
 }
 
 void CloudExternalDataManagerBaseTest::SetUpExternalDataManager() {
   external_data_manager_.reset(new CloudExternalDataManagerBase(
-      &kPolicyDefinitionList,
+      policy_details_.GetCallback(),
       message_loop_.message_loop_proxy(),
       message_loop_.message_loop_proxy()));
   external_data_manager_->SetExternalDataStore(make_scoped_ptr(
       new CloudExternalDataStore(kCacheKey,
                                  message_loop_.message_loop_proxy(),
                                  resource_cache_.get())));
   external_data_manager_->SetPolicyStore(&cloud_policy_store_);
 }
 
 scoped_ptr<base::DictionaryValue>
@@ skipping 549 matching lines @@
       ConstructMetadata(k20BytePolicyURL, base::SHA1HashString(k10ByteData)));
   cloud_policy_store_.NotifyStoreLoaded();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, callback_data_.size());
   ASSERT_TRUE(callback_data_[1]);
   EXPECT_EQ(k10ByteData, *callback_data_[1]);
   ResetCallbackData();
 }
 
 }  // namespace policy