Rename ServerBoundCert => ChannelID to reflect the current name

chrome/browser/browsing_data/browsing_data_remover.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/browsing_data/browsing_data_remover.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 49 matching lines @@
 #include "content/public/browser/plugin_data_remover.h"
 #include "content/public/browser/session_storage_usage_info.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/user_metrics.h"
 #include "net/base/net_errors.h"
 #include "net/base/sdch_manager.h"
 #include "net/cookies/cookie_store.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_cache.h"
 #include "net/http/transport_security_state.h"
-#include "net/ssl/server_bound_cert_service.h"
-#include "net/ssl/server_bound_cert_store.h"
+#include "net/ssl/channel_id_service.h"
+#include "net/ssl/channel_id_store.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "webkit/browser/quota/quota_manager.h"
 #include "webkit/browser/quota/special_storage_policy.h"
 #include "webkit/common/quota/quota_types.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chromeos/attestation/attestation_constants.h"
@@ skipping 105 matching lines @@
       special_storage_policy_(profile->GetExtensionSpecialStoragePolicy()),
       delete_begin_(delete_begin),
       delete_end_(delete_end),
       next_cache_state_(STATE_NONE),
       cache_(NULL),
       main_context_getter_(profile->GetRequestContext()),
       media_context_getter_(profile->GetMediaRequestContext()),
       deauthorize_content_licenses_request_id_(0),
       waiting_for_clear_autofill_origin_urls_(false),
       waiting_for_clear_cache_(false),
+      waiting_for_clear_channel_ids_(false),
       waiting_for_clear_content_licenses_(false),
       waiting_for_clear_cookies_count_(0),
       waiting_for_clear_domain_reliability_monitor_(false),
       waiting_for_clear_form_(false),
       waiting_for_clear_history_(false),
       waiting_for_clear_hostname_resolution_cache_(false),
       waiting_for_clear_keyword_data_(false),
       waiting_for_clear_logged_in_predictor_(false),
       waiting_for_clear_nacl_cache_(false),
       waiting_for_clear_network_predictor_(false),
       waiting_for_clear_networking_history_(false),
       waiting_for_clear_platform_keys_(false),
       waiting_for_clear_plugin_data_(false),
       waiting_for_clear_pnacl_cache_(false),
-      waiting_for_clear_server_bound_certs_(false),
       waiting_for_clear_storage_partition_data_(false),
 #if defined(ENABLE_WEBRTC)
       waiting_for_clear_webrtc_logs_(false),
 #endif
       remove_mask_(0),
       remove_origin_(GURL()),
       origin_set_mask_(0),
       storage_partition_for_testing_(NULL) {
   DCHECK(profile);
   // crbug.com/140910: Many places were calling this with base::Time() as
@@ skipping 229 matching lines @@
         BrowserThread::PostTask(
             BrowserThread::IO, FROM_HERE,
             base::Bind(&BrowsingDataRemover::ClearCookiesOnIOThread,
                        base::Unretained(this), base::Unretained(sb_context)));
       }
     }
 #endif
     MediaDeviceIDSalt::Reset(profile_->GetPrefs());
   }
 
-  // Server bound certs are not separated for protected and unprotected web
+  // Channel IDs are not separated for protected and unprotected web
   // origins. We check the origin_set_mask_ to prevent unintended deletion.
-  if (remove_mask & REMOVE_SERVER_BOUND_CERTS &&
+  if (remove_mask & REMOVE_CHANNEL_IDS &&
       origin_set_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
     content::RecordAction(
-        UserMetricsAction("ClearBrowsingData_ServerBoundCerts"));
+        UserMetricsAction("ClearBrowsingData_ChannelIDs"));
     // Since we are running on the UI thread don't call GetURLRequestContext().
     net::URLRequestContextGetter* rq_context = profile_->GetRequestContext();
     if (rq_context) {
-      waiting_for_clear_server_bound_certs_ = true;
+      waiting_for_clear_channel_ids_ = true;
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
-          base::Bind(&BrowsingDataRemover::ClearServerBoundCertsOnIOThread,
+          base::Bind(&BrowsingDataRemover::ClearChannelIDsOnIOThread,
                      base::Unretained(this), base::Unretained(rq_context)));
     }
   }
 
   if (remove_mask & REMOVE_LOCAL_STORAGE) {
     storage_partition_remove_mask |=
         content::StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE;
   }
 
   if (remove_mask & REMOVE_INDEXEDDB) {
@@ skipping 263 matching lines @@
       delete_begin_time = base::Time();
       break;
     default:
       NOTREACHED() << L"Missing item";
       break;
   }
   return delete_begin_time - diff;
 }
 
 bool BrowsingDataRemover::AllDone() {
-  return !waiting_for_clear_keyword_data_ &&
-         !waiting_for_clear_autofill_origin_urls_ &&
-         !waiting_for_clear_cache_ && !waiting_for_clear_nacl_cache_ &&
-         !waiting_for_clear_cookies_count_ && !waiting_for_clear_history_ &&
+  return !waiting_for_clear_autofill_origin_urls_ &&
+         !waiting_for_clear_cache_ &&
+         !waiting_for_clear_content_licenses_ &&
+         !waiting_for_clear_channel_ids_ &&
+         !waiting_for_clear_cookies_count_ &&
          !waiting_for_clear_domain_reliability_monitor_ &&
+         !waiting_for_clear_form_ &&
+         !waiting_for_clear_history_ &&
+         !waiting_for_clear_hostname_resolution_cache_ &&
+         !waiting_for_clear_keyword_data_ &&
          !waiting_for_clear_logged_in_predictor_ &&
+         !waiting_for_clear_nacl_cache_ &&
+         !waiting_for_clear_network_predictor_ &&
          !waiting_for_clear_networking_history_ &&
-         !waiting_for_clear_server_bound_certs_ &&
+         !waiting_for_clear_platform_keys_ &&
          !waiting_for_clear_plugin_data_ &&
          !waiting_for_clear_pnacl_cache_ &&
-         !waiting_for_clear_content_licenses_ && !waiting_for_clear_form_ &&
-         !waiting_for_clear_hostname_resolution_cache_ &&
-         !waiting_for_clear_network_predictor_ &&
-         !waiting_for_clear_platform_keys_ &&
 #if defined(ENABLE_WEBRTC)
          !waiting_for_clear_webrtc_logs_ &&
 #endif
          !waiting_for_clear_storage_partition_data_;
 }
 
 void BrowsingDataRemover::OnKeywordsLoaded() {
   // Deletes the entries from the model, and if we're not waiting on anything
   // else notifies observers and deletes this BrowsingDataRemover.
   TemplateURLService* model =
@@ skipping 329 matching lines @@
     net::URLRequestContextGetter* rq_context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   net::CookieStore* cookie_store = rq_context->
       GetURLRequestContext()->cookie_store();
   cookie_store->DeleteAllCreatedBetweenAsync(
       delete_begin_, delete_end_,
       base::Bind(&BrowsingDataRemover::OnClearedCookies,
                  base::Unretained(this)));
 }
 
-void BrowsingDataRemover::ClearServerBoundCertsOnIOThread(
+void BrowsingDataRemover::ClearChannelIDsOnIOThread(
     net::URLRequestContextGetter* rq_context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  net::ServerBoundCertService* server_bound_cert_service =
-      rq_context->GetURLRequestContext()->server_bound_cert_service();
-  server_bound_cert_service->GetCertStore()->DeleteAllCreatedBetween(
+  net::ChannelIDService* channel_id_service =
+      rq_context->GetURLRequestContext()->channel_id_service();
+  channel_id_service->GetChannelIDStore()->DeleteAllCreatedBetween(
       delete_begin_, delete_end_,
-      base::Bind(&BrowsingDataRemover::OnClearedServerBoundCertsOnIOThread,
+      base::Bind(&BrowsingDataRemover::OnClearedChannelIDsOnIOThread,
                  base::Unretained(this), base::Unretained(rq_context)));
 }
 
-void BrowsingDataRemover::OnClearedServerBoundCertsOnIOThread(
+void BrowsingDataRemover::OnClearedChannelIDsOnIOThread(
     net::URLRequestContextGetter* rq_context) {
   // Need to close open SSL connections which may be using the channel ids we
   // are deleting.
   // TODO(mattm): http://crbug.com/166069 Make the server bound cert
   // service/store have observers that can notify relevant things directly.
   rq_context->GetURLRequestContext()->ssl_config_service()->
       NotifySSLConfigChange();
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&BrowsingDataRemover::OnClearedServerBoundCerts,
+      base::Bind(&BrowsingDataRemover::OnClearedChannelIDs,
                  base::Unretained(this)));
 }
 
-void BrowsingDataRemover::OnClearedServerBoundCerts() {
+void BrowsingDataRemover::OnClearedChannelIDs() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  waiting_for_clear_server_bound_certs_ = false;
+  waiting_for_clear_channel_ids_ = false;
   NotifyAndDeleteIfDone();
 }
 
 void BrowsingDataRemover::OnClearedFormData() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   waiting_for_clear_form_ = false;
   NotifyAndDeleteIfDone();
 }
 
 void BrowsingDataRemover::OnClearedAutofillOriginURLs() {
@@ skipping 14 matching lines @@
   waiting_for_clear_webrtc_logs_ = false;
   NotifyAndDeleteIfDone();
 }
 #endif
 
 void BrowsingDataRemover::OnClearedDomainReliabilityMonitor() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   waiting_for_clear_domain_reliability_monitor_ = false;
   NotifyAndDeleteIfDone();
 }