Reverting this as it causes browser tests on the Linux ChromiumOS builder to fail.

chrome/browser/policy/user_cloud_policy_manager.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 "chrome/browser/policy/user_cloud_policy_manager.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
@@ skipping 38 matching lines @@
       store_(store.Pass()) {
   store_->Load();
   store_->AddObserver(this);
 }
 
 UserCloudPolicyManager::~UserCloudPolicyManager() {
   Shutdown();
   store_->RemoveObserver(this);
 }
 
+#if defined(OS_CHROMEOS)
 // static
 scoped_ptr<UserCloudPolicyManager> UserCloudPolicyManager::Create(
-    Profile* profile,
     bool wait_for_policy_fetch) {
-  scoped_ptr<CloudPolicyStore> store =
-      CloudPolicyStore::CreateUserPolicyStore(profile);
+  FilePath profile_dir;
+  CHECK(PathService::Get(chrome::DIR_USER_DATA, &profile_dir));
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  const FilePath policy_dir =
+      profile_dir
+          .Append(command_line->GetSwitchValuePath(switches::kLoginProfile))
+          .Append(kPolicyDir);
+  const FilePath policy_cache_file = policy_dir.Append(kPolicyCacheFile);
+  const FilePath token_cache_file = policy_dir.Append(kTokenCacheFile);
+
+  scoped_ptr<CloudPolicyStore> store(
+      new UserCloudPolicyStoreChromeOS(
+          chromeos::DBusThreadManager::Get()->GetSessionManagerClient(),
+          token_cache_file, policy_cache_file));
   return scoped_ptr<UserCloudPolicyManager>(
       new UserCloudPolicyManager(store.Pass(), wait_for_policy_fetch));
 }
+#endif
 
 void UserCloudPolicyManager::Initialize(PrefService* prefs,
                                         DeviceManagementService* service,
                                         UserAffiliation user_affiliation) {
-  DCHECK(service);
-  DCHECK(prefs);
   DCHECK(!service_.get());
   prefs_ = prefs;
   scoped_ptr<CloudPolicyClient> client(
       new CloudPolicyClient(std::string(), std::string(), user_affiliation,
                             POLICY_SCOPE_USER, NULL, service));
   service_.reset(new CloudPolicyService(client.Pass(), store_.get()));
   service_->client()->AddObserver(this);
 
   if (wait_for_policy_fetch_) {
     // If we are supposed to wait for a policy fetch, we trigger an explicit
@@ skipping 27 matching lines @@
   // can be started.
   if (service_.get() && !refresh_scheduler_.get() && prefs_) {
     refresh_scheduler_.reset(
         new CloudPolicyRefreshScheduler(
             service_->client(), store_.get(), prefs_,
             prefs::kUserPolicyRefreshRate,
             MessageLoop::current()->message_loop_proxy()));
   }
 }
 
-bool UserCloudPolicyManager::IsClientRegistered() const {
-  if (!service_.get())
-    return false;
-  return service_->client()->is_registered();
-}
-
-void UserCloudPolicyManager::RegisterClient(const std::string& access_token) {
-  DCHECK(cloud_policy_service()) << "Callers must invoke Initialize() first";
-  if (!cloud_policy_service()->client()->is_registered())
-    cloud_policy_service()->client()->Register(access_token);
-}
-
 bool UserCloudPolicyManager::IsInitializationComplete() const {
   return store_->is_initialized() && !wait_for_policy_fetch_;
 }
 
 void UserCloudPolicyManager::RefreshPolicies() {
   if (service_.get()) {
     wait_for_policy_refresh_ = true;
     service_->RefreshPolicy(
         base::Bind(&UserCloudPolicyManager::OnRefreshComplete,
                    base::Unretained(this)));
@@ skipping 47 matching lines @@
 void UserCloudPolicyManager::OnInitialPolicyFetchComplete() {
   CancelWaitForPolicyFetch();
 }
 
 void UserCloudPolicyManager::OnRefreshComplete() {
   wait_for_policy_refresh_ = false;
   CheckAndPublishPolicy();
 }
 
 }  // namespace policy