Split UserCloudPolicyManager implementation.

chrome/browser/policy/cloud_policy_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_POLICY_CLOUD_POLICY_MANAGER_H_
 #define CHROME_BROWSER_POLICY_CLOUD_POLICY_MANAGER_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/policy/cloud_policy_store.h"
 #include "chrome/browser/policy/configuration_policy_provider.h"
 
 class PrefService;
 
 namespace policy {
 
 class CloudPolicyClient;
 class CloudPolicyRefreshScheduler;
 class CloudPolicyService;
 
 // CloudPolicyManager is the main switching central between cloud policy and the
 // upper layers of the policy stack. It owns CloudPolicyStore,

[Joao da Silva, 2012/11/21 17:06:34]

The store is not owned anymore

[Mattias Nissler (ping if slow), 2012/11/22 20:51:59]

Done.

 // CloudPolicyClient, and CloudPolicyService, is responsible for receiving and
 // keeping policy from the cloud and exposes the decoded policy via the
 // ConfigurationPolicyProvider interface.
 //
 // This class contains the base functionality, there are subclasses that add
 // functionality specific to user-level and device-level cloud policy, such as
 // blocking on initial user policy fetch or device enrollment.
 class CloudPolicyManager : public ConfigurationPolicyProvider,
                            public CloudPolicyStore::Observer {
  public:
-  explicit CloudPolicyManager(scoped_ptr<CloudPolicyStore> store);
+  explicit CloudPolicyManager(CloudPolicyStore* store);
   virtual ~CloudPolicyManager();
 
   CloudPolicyClient* cloud_policy_client() { return client_.get(); }
   const CloudPolicyClient* cloud_policy_client() const { return client_.get(); }
 
-  CloudPolicyStore* cloud_policy_store() { return store_.get(); }
-  const CloudPolicyStore* cloud_policy_store() const { return store_.get(); }
+  CloudPolicyStore* cloud_policy_store() { return store_; }
+  const CloudPolicyStore* cloud_policy_store() const { return store_; }
 
   CloudPolicyService* cloud_policy_service() { return service_.get(); }
   const CloudPolicyService* cloud_policy_service() const {
     return service_.get();
   }
 
   // ConfigurationPolicyProvider:
   virtual void Shutdown() OVERRIDE;
   virtual bool IsInitializationComplete() const OVERRIDE;
   virtual void RefreshPolicies() OVERRIDE;
@@ skipping 15 matching lines @@
                              const std::string& refresh_rate_pref);
 
   // Check whether fully initialized and if so, publish policy by calling
   // ConfigurationPolicyStore::UpdatePolicy().
   void CheckAndPublishPolicy();
 
  private:
   // Completion handler for policy refresh operations.
   void OnRefreshComplete();
 
-  scoped_ptr<CloudPolicyStore> store_;
+  CloudPolicyStore* store_;

[Andrew T Wilson (Slow), 2012/11/21 17:34:24]

Since we don't own this, and this will likely get freed before this object is
freed (since our derived class will hold a reference to it) we probably should
document the semantics of use (i.e. do not access this from our destructor).

Should probably also clear this out in Shutdown(). OR, just go back to the way
it was where this class owned a pointer to the CloudPolicyStore :)

[Mattias Nissler (ping if slow), 2012/11/22 20:51:59]

I changed the code to NULL store_ in Shutdown() and added a DCHECK(!store_) to
the dtor, so we should be well-covered.

   scoped_ptr<CloudPolicyClient> client_;
   scoped_ptr<CloudPolicyService> service_;
   scoped_ptr<CloudPolicyRefreshScheduler> refresh_scheduler_;
 
   // Whether there's a policy refresh operation pending, in which case all
   // policy update notifications are deferred until after it completes.
   bool waiting_for_policy_refresh_;
 
   DISALLOW_COPY_AND_ASSIGN(CloudPolicyManager);
 };
 
 }  // namespace policy
 
 #endif  // CHROME_BROWSER_POLICY_CLOUD_POLICY_MANAGER_H_