Remove legacy policy cache support on chromeos

chrome/browser/chromeos/policy/user_cloud_policy_manager_factory_chromeos.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/chromeos/policy/user_cloud_policy_manager_factory_chromeos.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 25 matching lines @@
 #include "components/policy/policy_constants.h"
 #include "components/user_manager/user.h"
 #include "components/user_manager/user_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace policy {
 
 namespace {
 
-// Subdirectory in the user's profile for storing legacy user policies.
-const base::FilePath::CharType kDeviceManagementDir[] =
-    FILE_PATH_LITERAL("Device Management");
-
-// File in the above directory for storing legacy user policy dmtokens.
-const base::FilePath::CharType kToken[] = FILE_PATH_LITERAL("Token");
-
-// This constant is used to build two different paths. It can be a file inside
-// kDeviceManagementDir where legacy user policy data is stored, and it can be
-// a directory inside the profile directory where other resources are stored.
+// Directory under the profile directory where policy-related resources are
+// stored, see the follow constants for details.

[Andrew T Wilson (Slow), 2016/11/08 15:50:40]

nit: follow->following

 const base::FilePath::CharType kPolicy[] = FILE_PATH_LITERAL("Policy");
 
 // Directory under kPolicy, in the user's profile dir, where policy for
 // components is cached.
 const base::FilePath::CharType kComponentsDir[] =
     FILE_PATH_LITERAL("Components");
 
 // Directory in which to store external policy data. This is specified relative
 // to kPolicy.
 const base::FilePath::CharType kPolicyExternalDataDir[] =
@@ skipping 106 matching lines @@
     initial_policy_fetch_timeout =
         base::TimeDelta::FromSeconds(kInitialPolicyFetchTimeoutSeconds);
   }
 
   DeviceManagementService* device_management_service =
       connector->device_management_service();
   if (wait_for_policy_fetch)
     device_management_service->ScheduleInitialization(0);
 
   base::FilePath profile_dir = profile->GetPath();
-  const base::FilePath legacy_dir = profile_dir.Append(kDeviceManagementDir);
-  const base::FilePath policy_cache_file = legacy_dir.Append(kPolicy);
-  const base::FilePath token_cache_file = legacy_dir.Append(kToken);
   const base::FilePath component_policy_cache_dir =
       profile_dir.Append(kPolicy).Append(kComponentsDir);
   const base::FilePath external_data_dir =
         profile_dir.Append(kPolicy).Append(kPolicyExternalDataDir);
   base::FilePath policy_key_dir;
   CHECK(PathService::Get(chromeos::DIR_USER_POLICY_KEYS, &policy_key_dir));
 
   std::unique_ptr<UserCloudPolicyStoreChromeOS> store(
       new UserCloudPolicyStoreChromeOS(
           chromeos::DBusThreadManager::Get()->GetCryptohomeClient(),
           chromeos::DBusThreadManager::Get()->GetSessionManagerClient(),
-          background_task_runner, account_id, policy_key_dir, token_cache_file,
-          policy_cache_file));
+          background_task_runner, account_id, policy_key_dir));
 
   scoped_refptr<base::SequencedTaskRunner> backend_task_runner =
       content::BrowserThread::GetBlockingPool()->GetSequencedTaskRunner(
           content::BrowserThread::GetBlockingPool()->GetSequenceToken());
   scoped_refptr<base::SequencedTaskRunner> io_task_runner =
       content::BrowserThread::GetTaskRunnerForThread(
           content::BrowserThread::IO);
   std::unique_ptr<CloudExternalDataManager> external_data_manager(
       new UserCloudExternalDataManager(base::Bind(&GetChromePolicyDetails),
                                        backend_task_runner, io_task_runner,
@@ skipping 53 matching lines @@
 
 bool UserCloudPolicyManagerFactoryChromeOS::HasTestingFactory(
     content::BrowserContext* context) {
   return false;
 }
 
 void UserCloudPolicyManagerFactoryChromeOS::CreateServiceNow(
     content::BrowserContext* context) {}
 
 }  // namespace policy