Using PolicyServiceWatcher instead of PolicyWatcherLinux/Win/Mac.

components/policy/core/common/policy_loader_mac.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_mac.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/files/file_util.h"
@@ skipping 14 matching lines @@
 using base::ScopedCFTypeRef;
 
 namespace policy {
 
 PolicyLoaderMac::PolicyLoaderMac(
     scoped_refptr<base::SequencedTaskRunner> task_runner,
     const base::FilePath& managed_policy_path,
     MacPreferences* preferences)
     : AsyncPolicyLoader(task_runner),
       preferences_(preferences),
-      managed_policy_path_(managed_policy_path) {}
+      managed_policy_path_(managed_policy_path),
+      application_id_(kCFPreferencesCurrentApplication) {
+}
+
+PolicyLoaderMac::PolicyLoaderMac(
+    scoped_refptr<base::SequencedTaskRunner> task_runner,
+    const base::FilePath& managed_policy_path,
+    MacPreferences* preferences,
+    CFStringRef application_id)
+    : AsyncPolicyLoader(task_runner),
+      preferences_(preferences),
+      managed_policy_path_(managed_policy_path),
+      application_id_(application_id) {
+}
 
 PolicyLoaderMac::~PolicyLoaderMac() {}
 
 void PolicyLoaderMac::InitOnBackgroundThread() {
   if (!managed_policy_path_.empty()) {
     watcher_.Watch(
         managed_policy_path_, false,
         base::Bind(&PolicyLoaderMac::OnFileUpdated, base::Unretained(this)));
   }
 }
 
 scoped_ptr<PolicyBundle> PolicyLoaderMac::Load() {
-  preferences_->AppSynchronize(kCFPreferencesCurrentApplication);
+  preferences_->AppSynchronize(application_id_);
   scoped_ptr<PolicyBundle> bundle(new PolicyBundle());
 
   // Load Chrome's policy.
   PolicyMap& chrome_policy =
       bundle->Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()));
 
   PolicyLoadStatusSample status;
   bool policy_present = false;
   const Schema* schema =
       schema_map()->GetSchema(PolicyNamespace(POLICY_DOMAIN_CHROME, ""));
   for (Schema::Iterator it = schema->GetPropertiesIterator();
        !it.IsAtEnd(); it.Advance()) {
     base::ScopedCFTypeRef<CFStringRef> name(
         base::SysUTF8ToCFStringRef(it.key()));
     base::ScopedCFTypeRef<CFPropertyListRef> value(
-        preferences_->CopyAppValue(name, kCFPreferencesCurrentApplication));
+        preferences_->CopyAppValue(name, application_id_));
     if (!value.get())
       continue;
     policy_present = true;
-    bool forced =
-        preferences_->AppValueIsForced(name, kCFPreferencesCurrentApplication);
+    bool forced = preferences_->AppValueIsForced(name, application_id_);
     PolicyLevel level = forced ? POLICY_LEVEL_MANDATORY :
                                  POLICY_LEVEL_RECOMMENDED;
     // TODO(joaodasilva): figure the policy scope.
     scoped_ptr<base::Value> policy = PropertyToValue(value);
     if (policy) {
       chrome_policy.Set(
           it.key(), level, POLICY_SCOPE_USER, policy.release(), NULL);
     } else {
       status.Add(POLICY_LOAD_STATUS_PARSE_ERROR);
     }
@@ skipping 71 matching lines @@
     }
   }
 }
 
 void PolicyLoaderMac::OnFileUpdated(const base::FilePath& path, bool error) {
   if (!error)
     Reload(false);
 }
 
 }  // namespace policy