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) {
+    ScopedVector<DeviceManagementService> device_management_services) {
   DCHECK(!is_initialized());
 
-  device_management_service_ = device_management_service.Pass();
+  device_management_services_ = device_management_services.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();
+  device_management_services_.clear();
 }
 
 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 15 matching lines @@
 const Schema& BrowserPolicyConnector::GetChromeSchema() const {
   return chrome_schema_;
 }
 
 CombinedSchemaRegistry* BrowserPolicyConnector::GetSchemaRegistry() {
   return &schema_registry_;
 }
 
 void BrowserPolicyConnector::ScheduleServiceInitialization(
     int64 delay_milliseconds) {
   // Skip device initialization if the BrowserPolicyConnector was never

[bartfab (slow), 2014/04/23 12:17:18]

Nit: That comment is no longer necessary. If |device_management_services_| is
empty, the method will obviously do nothing.

[davidyu, 2014/04/23 12:56:58]

Code reverted.

   // initialized (unit tests).
-  if (device_management_service_)
-    device_management_service_->ScheduleInitialization(delay_milliseconds);
+  for (ScopedVector<DeviceManagementService>::const_iterator i =

[bartfab (slow), 2014/04/23 12:17:18]

Nit: The most common variable name for iterators in Chrome code is "it."

[davidyu, 2014/04/23 12:56:58]

Code removed.

+           device_management_services_.begin();
+       i != device_management_services_.end();
+       ++i) {
+    (*i)->ScheduleInitialization(delay_milliseconds);
+  }
 }
 
 const ConfigurationPolicyHandlerList*
     BrowserPolicyConnector::GetHandlerList() const {
   return handler_list_.get();
 }
 
+DeviceManagementService* BrowserPolicyConnector::GetDeviceManagementService(
+    ManagementMode management_mode) {
+  return device_management_services_[management_mode];

[bartfab (slow), 2014/04/23 12:17:18]

Nit: Add DCHECKs to verify that we were not given an invalid |management_mode|.

Alternatively, and I would prefer this solution, replace the ScopedVector with
two members, enterprise_device_management_service_ and
consumer_device_management_service_. We are not planning to expand beyond two
DMSs anytime soon anyway, so a vector is a bit of an overkill.

[davidyu, 2014/04/23 12:56:58]

Done.

+}
+
 // 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:
+      return std::string();

[bartfab (slow), 2014/04/23 12:17:18]

Nit: Add a NOTREACHED().

[davidyu, 2014/04/23 12:56:58]

Done.

+  }
 }
 
 // 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