Add consumer_device_management_service() in BrowserPolicyConnectorChromeOS.

chrome/browser/policy/chrome_browser_policy_connector.cc

 // 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.
 
 #include "chrome/browser/policy/chrome_browser_policy_connector.h"
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 61 matching lines @@
   if (!bundle_id)
     return base::FilePath();
 
   return path.Append(base::SysCFStringRefToUTF8(bundle_id) + ".plist");
 }
 #endif  // defined(OS_MACOSX)
 
 class DeviceManagementServiceConfiguration
     : public DeviceManagementService::Configuration {
  public:
-  DeviceManagementServiceConfiguration() {}
+  explicit DeviceManagementServiceConfiguration(

[Mattias Nissler (ping if slow), 2014/04/23 14:32:39]

Note that this file is the cross-platform BrowserPolicyConnector, it should not
contain any bits specific to Chrome OS. Is consumer management expected to be
available on other Chrome platforms as well in the near future? If not, this
should move to browser_policy_connector_chromeos.cc

It may make sense to extract DeviceManagementServiceConfiguration into a
publicly-available class, in that case I'd prefer to just pass the URL as the
parameter, not the enum (that'll be more flexible for tests etc.).

[davidyu, 2014/04/23 15:22:50]

I don't think we will make this feature available on other platforms anytime
soon. Do you think I should also move the related in BrowserPolicyConnector to
BrowserPolicyConnectorChromeOS as well?

[Mattias Nissler (ping if slow), 2014/04/23 15:25:18]

Yes, everything related to consumer management should be in the
BrowserPolicyConnectorChromeOS then.

[davidyu, 2014/04/24 04:52:41]

Done.

+      BrowserPolicyConnector::ManagementMode management_mode)
+      : management_mode_(management_mode) {}
   virtual ~DeviceManagementServiceConfiguration() {}
 
   virtual std::string GetServerUrl() OVERRIDE {
-    return BrowserPolicyConnector::GetDeviceManagementUrl();
+    return BrowserPolicyConnector::GetDeviceManagementUrl(management_mode_);
   }
 
   virtual std::string GetAgentParameter() OVERRIDE {
     chrome::VersionInfo version_info;
     return base::StringPrintf("%s %s(%s)",
                               version_info.Name().c_str(),
                               version_info.Version().c_str(),
                               version_info.LastChange().c_str());
   }
 
@@ skipping 24 matching lines @@
                                                  &os_bugfix_version);
     os_version = base::StringPrintf("%d.%d.%d",
                                     os_major_version,
                                     os_minor_version,
                                     os_bugfix_version);
 #endif
 
     return base::StringPrintf(
         "%s|%s|%s", os_name.c_str(), os_hardware.c_str(), os_version.c_str());
   }
+
+ private:
+  BrowserPolicyConnector::ManagementMode management_mode_;
 };
 
 }  // namespace
 
 ChromeBrowserPolicyConnector::ChromeBrowserPolicyConnector()
     : BrowserPolicyConnector(base::Bind(&BuildHandlerList)) {
   ConfigurationPolicyProvider* platform_provider = CreatePlatformProvider();
   if (platform_provider)
     SetPlatformPolicyProvider(make_scoped_ptr(platform_provider));
 }
 
 ChromeBrowserPolicyConnector::~ChromeBrowserPolicyConnector() {}
 
 void ChromeBrowserPolicyConnector::Init(
     PrefService* local_state,
     scoped_refptr<net::URLRequestContextGetter> request_context) {
   // Initialization of some of the providers requires the FILE thread; make
   // sure that threading is ready at this point.
   DCHECK(BrowserThread::IsThreadInitialized(BrowserThread::FILE));
 
-  scoped_ptr<DeviceManagementService::Configuration> configuration(
-      new DeviceManagementServiceConfiguration);
-  scoped_ptr<DeviceManagementService> device_management_service(
-      new DeviceManagementService(configuration.Pass()));
-  device_management_service->ScheduleInitialization(
+  scoped_ptr<DeviceManagementService::Configuration> enterprise_configuration(
+      new DeviceManagementServiceConfiguration(ENTERPRISE_MANAGED));
+  scoped_ptr<DeviceManagementService> enterprise_service(
+      new DeviceManagementService(enterprise_configuration.Pass()));
+  enterprise_service->ScheduleInitialization(
       kServiceInitializationStartupDelay);
 
-  BrowserPolicyConnector::Init(
-      local_state, request_context, device_management_service.Pass());
+  scoped_ptr<DeviceManagementService::Configuration> consumer_configuration(
+      new DeviceManagementServiceConfiguration(CONSUMER_MANAGED));
+  scoped_ptr<DeviceManagementService> consumer_service(
+      new DeviceManagementService(consumer_configuration.Pass()));
+  consumer_service->ScheduleInitialization(
+      kServiceInitializationStartupDelay);
+
+  BrowserPolicyConnector::Init(local_state,
+                               request_context,
+                               enterprise_service.Pass(),
+                               consumer_service.Pass());
 }
 
 ConfigurationPolicyProvider*
     ChromeBrowserPolicyConnector::CreatePlatformProvider() {
 #if defined(OS_WIN)
   scoped_ptr<AsyncPolicyLoader> loader(PolicyLoaderWin::Create(
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
       kRegistryChromePolicyKey));
   return new AsyncPolicyProvider(GetSchemaRegistry(), loader.Pass());
 #elif defined(OS_MACOSX)
@@ skipping 14 matching lines @@
     return NULL;
   }
 #elif defined(OS_ANDROID)
   return new PolicyProviderAndroid();
 #else
   return NULL;
 #endif
 }
 
 }  // namespace policy