Introduce a new error code from the DM server - 402 - missing licenses.

chrome/browser/policy/device_token_fetcher.cc

 // 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.
 
 #include "chrome/browser/policy/device_token_fetcher.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
@@ skipping 42 matching lines @@
       break;
     case DM_STATUS_SERVICE_DEVICE_ID_CONFLICT:
       sample = kMetricTokenFetchDeviceIdConflict;
       break;
     case DM_STATUS_SERVICE_INVALID_SERIAL_NUMBER:
       sample = kMetricTokenFetchInvalidSerialNumber;
       break;
     case DM_STATUS_RESPONSE_DECODING_ERROR:
       sample = kMetricTokenFetchBadResponse;
       break;
+    case DM_STATUS_MISSING_LICENSES:
+      sample = kMetricMissingLicenses;
+      break;
     case DM_STATUS_TEMPORARY_UNAVAILABLE:
     case DM_STATUS_SERVICE_ACTIVATION_PENDING:
     case DM_STATUS_SERVICE_POLICY_NOT_FOUND:
     case DM_STATUS_HTTP_STATUS_ERROR:
       sample = kMetricTokenFetchServerFailed;
       break;
   }
   if (sample != -1)
     UMA_HISTOGRAM_ENUMERATION(kMetricToken, sample, kMetricTokenSize);
   else
@@ skipping 55 matching lines @@
   // the timestamp that |SetState()| needs to determine the correct refresh
   // time.
   cache_->SetUnmanaged();
   SetState(STATE_UNMANAGED);
 }
 
 void DeviceTokenFetcher::SetSerialNumberInvalidState() {
   SetState(STATE_BAD_SERIAL);
 }
 
+void DeviceTokenFetcher::SetMissingLicensesState() {
+  SetState(STATE_MISSING_LICENSES);
+}
+
 void DeviceTokenFetcher::Reset() {
   SetState(STATE_INACTIVE);
 }
 
 void DeviceTokenFetcher::Initialize(DeviceManagementService* service,
                                     CloudPolicyCacheBase* cache,
                                     CloudPolicyDataStore* data_store,
                                     PolicyNotifier* notifier,
                                     DelayedWorkScheduler* scheduler) {
   service_ = service;
@@ skipping 95 matching lines @@
       SetState(STATE_TEMPORARY_ERROR);
       return;
     case DM_STATUS_SERVICE_MANAGEMENT_TOKEN_INVALID:
       // Most probably the GAIA auth cookie has expired. We can not do anything
       // until the user logs-in again.
       SetState(STATE_BAD_AUTH);
       return;
     case DM_STATUS_SERVICE_INVALID_SERIAL_NUMBER:
       SetSerialNumberInvalidState();
       return;
+    case DM_STATUS_MISSING_LICENSES:
+      SetMissingLicensesState();
+      return;
     case DM_STATUS_REQUEST_INVALID:
     case DM_STATUS_HTTP_STATUS_ERROR:
     case DM_STATUS_RESPONSE_DECODING_ERROR:
     case DM_STATUS_SERVICE_ACTIVATION_PENDING:
     case DM_STATUS_SERVICE_POLICY_NOT_FOUND:
       SetState(STATE_ERROR);
       return;
   }
   NOTREACHED();
   SetState(STATE_ERROR);
@@ skipping 21 matching lines @@
     case STATE_BAD_SERIAL:
       notifier_->Inform(CloudPolicySubsystem::UNENROLLED,
                         CloudPolicySubsystem::BAD_SERIAL_NUMBER,
                         PolicyNotifier::TOKEN_FETCHER);
       break;
     case STATE_BAD_ENROLLMENT_MODE:
       notifier_->Inform(CloudPolicySubsystem::UNENROLLED,
                         CloudPolicySubsystem::BAD_ENROLLMENT_MODE,
                         PolicyNotifier::TOKEN_FETCHER);
       break;
+    case STATE_MISSING_LICENSES:
+      notifier_->Inform(CloudPolicySubsystem::UNENROLLED,
+                        CloudPolicySubsystem::MISSING_LICENSES,
+                        PolicyNotifier::TOKEN_FETCHER);
+      break;
     case STATE_UNMANAGED:
       delayed_work_at = cache_->last_policy_refresh_time() +
           base::TimeDelta::FromMilliseconds(
               kUnmanagedDeviceRefreshRateMilliseconds);
       notifier_->Inform(CloudPolicySubsystem::UNMANAGED,
                         CloudPolicySubsystem::NO_DETAILS,
                         PolicyNotifier::TOKEN_FETCHER);
       break;
     case STATE_TEMPORARY_ERROR:
       delayed_work_at = base::Time::Now() +
@@ skipping 36 matching lines @@
   if (state_ != STATE_INACTIVE && state_ != STATE_TOKEN_AVAILABLE)
     cache_->SetFetchingDone();
 }
 
 void DeviceTokenFetcher::DoWork() {
   switch (state_) {
     case STATE_INACTIVE:
     case STATE_TOKEN_AVAILABLE:
     case STATE_BAD_SERIAL:
     case STATE_BAD_ENROLLMENT_MODE:
+    case STATE_MISSING_LICENSES:
       break;
     case STATE_UNMANAGED:
     case STATE_ERROR:
     case STATE_TEMPORARY_ERROR:
     case STATE_BAD_AUTH:
       FetchTokenInternal();
       break;
   }
 }
 
 }  // namespace policy