Purge cache when the server removes the policy for an extension.

components/policy/core/common/cloud/cloud_policy_client.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 "components/policy/core/common/cloud/cloud_policy_client.h"
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 202 matching lines @@
       key_update_request->add_server_backed_state_key(*key);
     }
   }
 
   // Set the fetched invalidation version to the latest invalidation version
   // since it is now the invalidation version used for the latest fetch.
   fetched_invalidation_version_ = invalidation_version_;
 
   // Fire the job.
   request_job_->Start(base::Bind(&CloudPolicyClient::OnPolicyFetchCompleted,
-                                 base::Unretained(this)));
+                                 base::Unretained(this),
+                                 namespaces_to_fetch_));
 }
 
 void CloudPolicyClient::FetchRobotAuthCodes(const std::string& auth_token) {
   CHECK(is_registered());
   DCHECK(!auth_token.empty());
 
   request_job_.reset(service_->CreateJob(
       DeviceManagementRequestJob::TYPE_API_AUTH_CODE_FETCH,
       GetRequestContext()));
   // The credentials of a domain user are needed in order to mint a new OAuth2
@@ skipping 135 matching lines @@
     DVLOG(1) << "Device robot account auth code fetch complete - code = "
              << robot_api_auth_code_;
 
     NotifyRobotAuthCodesFetched();
   } else {
     NotifyClientError();
   }
 }
 
 void CloudPolicyClient::OnPolicyFetchCompleted(
+    const NamespaceSet& namespaces_requested,
     DeviceManagementStatus status,
     int net_error,
     const em::DeviceManagementResponse& response) {
   if (status == DM_STATUS_SUCCESS) {
     if (!response.has_policy_response() ||
         response.policy_response().response_size() == 0) {
       LOG(WARNING) << "Empty policy response.";
       status = DM_STATUS_RESPONSE_DECODING_ERROR;
     }
   }
 
   status_ = status;
   if (status == DM_STATUS_SUCCESS) {
+    namespaces_requested_ = namespaces_requested;
+    STLDeleteValues(&responses_);
     const em::DevicePolicyResponse& policy_response =
         response.policy_response();
-    STLDeleteValues(&responses_);
     for (int i = 0; i < policy_response.response_size(); ++i) {
       const em::PolicyFetchResponse& response = policy_response.response(i);
       em::PolicyData policy_data;
       if (!policy_data.ParseFromString(response.policy_data()) ||
           !policy_data.IsInitialized() ||
           !policy_data.has_policy_type()) {
         LOG(WARNING) << "Invalid PolicyData received, ignoring";
         continue;
       }
       const std::string& type = policy_data.policy_type();
@@ skipping 65 matching lines @@
 
 void CloudPolicyClient::NotifyRobotAuthCodesFetched() {
   FOR_EACH_OBSERVER(Observer, observers_, OnRobotAuthCodesFetched(this));
 }
 
 void CloudPolicyClient::NotifyClientError() {
   FOR_EACH_OBSERVER(Observer, observers_, OnClientError(this));
 }
 
 }  // namespace policy