Add consumer_device_management_service() in BrowserPolicyConnectorChromeOS.

components/policy/core/browser/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 "components/policy/core/browser/browser_policy_connector.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 13 matching lines @@
 #include "components/policy/core/common/policy_switches.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "policy/policy_constants.h"
 #include "third_party/icu/source/i18n/unicode/regex.h"
 
 namespace policy {
 
 namespace {
 
-// The URL for the device management server.
-const char kDefaultDeviceManagementServerUrl[] =
+// The URL for the enterprise device management server.
+const char kDefaultEnterpriseDeviceManagementServerUrl[] =
+    "https://m.google.com/devicemanagement/data/api";
+
+// TODO(davidyu): use the right URL once the server is ready.
+// The URL for the consumer device management server.
+const char kDefaultConsumerDeviceManagementServerUrl[] =
     "https://m.google.com/devicemanagement/data/api";
 
 // Used in BrowserPolicyConnector::SetPolicyProviderForTesting.
 bool g_created_policy_service = false;
 ConfigurationPolicyProvider* g_testing_provider = NULL;
 
 // Returns true if |domain| matches the regex |pattern|.
 bool MatchDomain(const base::string16& domain, const base::string16& pattern) {
   UErrorCode status = U_ZERO_ERROR;
   const icu::UnicodeString icu_pattern(pattern.data(), pattern.length());
@@ skipping 32 matching lines @@
     // This usually means it's an early shutdown and
     // BrowserProcessImpl::StartTearDown() wasn't invoked.
     // Cleanup properly in those cases and avoid crashing the ToastCrasher test.
     Shutdown();
   }
 }
 
 void BrowserPolicyConnector::Init(
     PrefService* local_state,
     scoped_refptr<net::URLRequestContextGetter> request_context,
-    scoped_ptr<DeviceManagementService> device_management_service) {
+    scoped_ptr<DeviceManagementService> enterprise_device_management_service,
+    scoped_ptr<DeviceManagementService> consumer_device_management_service) {
   DCHECK(!is_initialized());
 
-  device_management_service_ = device_management_service.Pass();
+  enterprise_device_management_service_ =
+      enterprise_device_management_service.Pass();
+  consumer_device_management_service_ =
+      consumer_device_management_service.Pass();
 
   if (g_testing_provider)
     g_testing_provider->Init(GetSchemaRegistry());
   for (size_t i = 0; i < policy_providers_.size(); ++i)
     policy_providers_[i]->Init(GetSchemaRegistry());
 
   policy_statistics_collector_.reset(
       new policy::PolicyStatisticsCollector(
           base::Bind(&GetChromePolicyDetails),
           GetChromeSchema(),
           GetPolicyService(),
           local_state,
           base::MessageLoop::current()->message_loop_proxy()));
   policy_statistics_collector_->Initialize();
 
   is_initialized_ = true;
 }
 
 void BrowserPolicyConnector::Shutdown() {
   is_initialized_ = false;
   if (g_testing_provider)
     g_testing_provider->Shutdown();
   for (size_t i = 0; i < policy_providers_.size(); ++i)
     policy_providers_[i]->Shutdown();
   // Drop g_testing_provider so that tests executed with --single_process can
   // call SetPolicyProviderForTesting() again. It is still owned by the test.
   g_testing_provider = NULL;
-  device_management_service_.reset();
+  enterprise_device_management_service_.reset();
+  consumer_device_management_service_.reset();
 }
 
 PolicyService* BrowserPolicyConnector::GetPolicyService() {
   if (!policy_service_) {
     g_created_policy_service = true;
     std::vector<ConfigurationPolicyProvider*> providers;
     if (g_testing_provider) {
       providers.push_back(g_testing_provider);
     } else {
       providers.resize(policy_providers_.size());
@@ skipping 17 matching lines @@
 }
 
 CombinedSchemaRegistry* BrowserPolicyConnector::GetSchemaRegistry() {
   return &schema_registry_;
 }
 
 void BrowserPolicyConnector::ScheduleServiceInitialization(
     int64 delay_milliseconds) {
   // Skip device initialization if the BrowserPolicyConnector was never
   // initialized (unit tests).
-  if (device_management_service_)
-    device_management_service_->ScheduleInitialization(delay_milliseconds);
+  if (enterprise_device_management_service_)
+    enterprise_device_management_service_->
+        ScheduleInitialization(delay_milliseconds);
+  if (consumer_device_management_service_)
+    consumer_device_management_service_->
+        ScheduleInitialization(delay_milliseconds);
 }
 
 const ConfigurationPolicyHandlerList*
     BrowserPolicyConnector::GetHandlerList() const {
   return handler_list_.get();
 }
 
+DeviceManagementService* BrowserPolicyConnector::GetDeviceManagementService(
+    ManagementMode management_mode) {
+  switch (management_mode) {
+    case ENTERPRISE_MANAGED:
+      return enterprise_device_management_service_.get();
+
+    case CONSUMER_MANAGED:
+      return consumer_device_management_service_.get();
+
+    default:
+      NOTREACHED();
+      return NULL;
+  }
+}
+
 // static
 void BrowserPolicyConnector::SetPolicyProviderForTesting(
     ConfigurationPolicyProvider* provider) {
   // If this function is used by a test then it must be called before the
   // browser is created, and GetPolicyService() gets called.
   CHECK(!g_created_policy_service);
   DCHECK(!g_testing_provider);
   g_testing_provider = provider;
 }
 
@@ skipping 25 matching lines @@
       gaia::ExtractDomainName(gaia::CanonicalizeEmail(username)));
   for (size_t i = 0; i < arraysize(kNonManagedDomainPatterns); i++) {
     base::string16 pattern = base::WideToUTF16(kNonManagedDomainPatterns[i]);
     if (MatchDomain(domain, pattern))
       return true;
   }
   return false;
 }
 
 // static
-std::string BrowserPolicyConnector::GetDeviceManagementUrl() {
+std::string BrowserPolicyConnector::GetDeviceManagementUrl(
+    ManagementMode management_mode) {
   CommandLine* command_line = CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(switches::kDeviceManagementUrl))
-    return command_line->GetSwitchValueASCII(switches::kDeviceManagementUrl);
-  else
-    return kDefaultDeviceManagementServerUrl;
+  switch (management_mode) {
+    case ENTERPRISE_MANAGED:
+      if (command_line->HasSwitch(switches::kDeviceManagementUrl))
+        return command_line->GetSwitchValueASCII(
+            switches::kDeviceManagementUrl);
+      else
+        return kDefaultEnterpriseDeviceManagementServerUrl;
+
+    case CONSUMER_MANAGED:
+      if (command_line->HasSwitch(switches::kConsumerDeviceManagementUrl))
+        return command_line->GetSwitchValueASCII(
+            switches::kConsumerDeviceManagementUrl);
+      else
+        return kDefaultConsumerDeviceManagementServerUrl;
+
+    default:
+      NOTREACHED();
+      return std::string();
+  }
 }
 
 // static
 void BrowserPolicyConnector::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterIntegerPref(
       policy_prefs::kUserPolicyRefreshRate,
       CloudPolicyRefreshScheduler::kDefaultRefreshDelayMs);
 }
 
 void BrowserPolicyConnector::AddPolicyProvider(
     scoped_ptr<ConfigurationPolicyProvider> provider) {
   policy_providers_.push_back(provider.release());
 }
 
 void BrowserPolicyConnector::SetPlatformPolicyProvider(
     scoped_ptr<ConfigurationPolicyProvider> provider) {
   CHECK(!platform_policy_provider_);
   platform_policy_provider_ = provider.get();
   AddPolicyProvider(provider.Pass());
 }
 
 }  // namespace policy