Add consumer_device_management_service() in BrowserPolicyConnectorChromeOS.

components/policy/core/browser/browser_policy_connector.h

 // Copyright 2014 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 COMPONENTS_POLICY_CORE_BROWSER_BROWSER_POLICY_CONNECTOR_H_
 #define COMPONENTS_POLICY_CORE_BROWSER_BROWSER_POLICY_CONNECTOR_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 18 matching lines @@
 class DeviceManagementService;
 class PolicyService;
 class PolicyStatisticsCollector;
 
 // The BrowserPolicyConnector keeps the browser-global (non Profile-specific)
 // policy providers, and some shared components of the policy system.
 // This is a basic implementation that gets extended by platform-specific
 // subclasses.
 class POLICY_EXPORT BrowserPolicyConnector {
  public:
+  enum ManagementMode {
+    NOT_MANAGED,
+    ENTERPRISE_MANAGED,
+    CONSUMER_MANAGED
+  };
+
   // Invoke Shutdown() before deleting, see below.
   virtual ~BrowserPolicyConnector();
 
   // Finalizes the initialization of the connector. This call can be skipped on
   // tests that don't require the full policy system running.
   virtual void Init(
       PrefService* local_state,
       scoped_refptr<net::URLRequestContextGetter> request_context) = 0;
 
   // Stops the policy providers and cleans up the connector before it can be
@@ skipping 19 matching lines @@
 
   // Returns the platform-specific policy provider, if there is one.
   ConfigurationPolicyProvider* GetPlatformProvider();
 
   // Schedules initialization of the cloud policy backend services, if the
   // services are already constructed.
   void ScheduleServiceInitialization(int64 delay_milliseconds);
 
   const ConfigurationPolicyHandlerList* GetHandlerList() const;
 
+  // TODO(davidyu): migrate all callers to use GetDeviceManagementService()
+  // instead. http://crbug.com/366085.
   DeviceManagementService* device_management_service() {
-    return device_management_service_.get();
+    return GetDeviceManagementService(ENTERPRISE_MANAGED);
   }
 
+  // Returns the device management service based on the management mode.
+  // |management_mode| must not be NOT_MANAGED.
+  DeviceManagementService* GetDeviceManagementService(
+      ManagementMode management_mode);
+
   // Sets a |provider| that will be included in PolicyServices returned by
   // GetPolicyService. This is a static method because local state is
   // created immediately after the connector, and tests don't have a chance to
   // inject the provider otherwise. |provider| must outlive the connector, and
   // its ownership is not taken though the connector will initialize and shut it
   // down.
   static void SetPolicyProviderForTesting(
       ConfigurationPolicyProvider* provider);
 
   // Check whether a user is known to be non-enterprise. Domains such as
   // gmail.com and googlemail.com are known to not be managed. Also returns
   // false if the username is empty.
   static bool IsNonEnterpriseUser(const std::string& username);
 
   // Returns the URL for the device management service endpoint.
-  static std::string GetDeviceManagementUrl();
+  // |management_mode| must not be NOT_MANAGED.
+  static std::string GetDeviceManagementUrl(ManagementMode management_mode);
 
   // Registers refresh rate prefs.
   static void RegisterPrefs(PrefRegistrySimple* registry);
 
  protected:
   // Builds an uninitialized BrowserPolicyConnector.
   // Init() should be called to create and start the policy components.
   explicit BrowserPolicyConnector(
       const HandlerListFactory& handler_list_factory);
 
   // Helper for the public Init() that must be called by subclasses.
   void Init(PrefService* local_state,
             scoped_refptr<net::URLRequestContextGetter> request_context,
-            scoped_ptr<DeviceManagementService> device_management_service);
+            scoped_ptr<DeviceManagementService>
+            enterprise_device_management_services,
+            scoped_ptr<DeviceManagementService>
+            consumer_device_management_services);
 
   // Adds |provider| to the list of |policy_providers_|. Providers should
   // be added in decreasing order of priority.
   void AddPolicyProvider(scoped_ptr<ConfigurationPolicyProvider> provider);
 
   // Same as AddPolicyProvider(), but |provider| becomes the platform provider
   // which can be retrieved by GetPlatformProvider(). This can be called at
   // most once, and uses the same priority order as AddPolicyProvider().
   void SetPlatformPolicyProvider(
       scoped_ptr<ConfigurationPolicyProvider> provider);
@@ skipping 17 matching lines @@
 
   // The browser-global policy providers, in decreasing order of priority.
   ScopedVector<ConfigurationPolicyProvider> policy_providers_;
   ConfigurationPolicyProvider* platform_policy_provider_;
 
   // Must be deleted before all the policy providers.
   scoped_ptr<PolicyService> policy_service_;
 
   scoped_ptr<PolicyStatisticsCollector> policy_statistics_collector_;
 
-  scoped_ptr<DeviceManagementService> device_management_service_;
+  scoped_ptr<DeviceManagementService> enterprise_device_management_service_;
+  scoped_ptr<DeviceManagementService> consumer_device_management_service_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserPolicyConnector);
 };
 
 }  // namespace policy
 
 #endif  // COMPONENTS_POLICY_CORE_BROWSER_BROWSER_POLICY_CONNECTOR_H_