Remove PeerConnectionIdentityStore and related messaging/storage code.

content/browser/storage_partition_impl.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 "content/browser/storage_partition_impl.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <vector>
@@ skipping 300 matching lines @@
 
   void ClearDataOnUIThread(
       const GURL& storage_origin,
       const OriginMatcherFunction& origin_matcher,
       const CookieMatcherFunction& cookie_matcher,
       const base::FilePath& path,
       net::URLRequestContextGetter* rq_context,
       DOMStorageContextWrapper* dom_storage_context,
       storage::QuotaManager* quota_manager,
       storage::SpecialStoragePolicy* special_storage_policy,
-      WebRTCIdentityStore* webrtc_identity_store,
       storage::FileSystemContext* filesystem_context,
       const base::Time begin,
       const base::Time end);
 
   void ClearQuotaManagedDataOnIOThread(
       const scoped_refptr<storage::QuotaManager>& quota_manager,
       const base::Time begin,
       const GURL& storage_origin,
       const scoped_refptr<storage::SpecialStoragePolicy>&
           special_storage_policy,
@@ skipping 32 matching lines @@
     BrowserContext* browser_context,
     const base::FilePath& partition_path,
     storage::QuotaManager* quota_manager,
     ChromeAppCacheService* appcache_service,
     storage::FileSystemContext* filesystem_context,
     storage::DatabaseTracker* database_tracker,
     DOMStorageContextWrapper* dom_storage_context,
     IndexedDBContextImpl* indexed_db_context,
     CacheStorageContextImpl* cache_storage_context,
     ServiceWorkerContextWrapper* service_worker_context,
-    WebRTCIdentityStore* webrtc_identity_store,
     storage::SpecialStoragePolicy* special_storage_policy,
     HostZoomLevelContext* host_zoom_level_context,
     PlatformNotificationContextImpl* platform_notification_context,
     BackgroundSyncContext* background_sync_context,
     scoped_refptr<webmessaging::BroadcastChannelProvider>
         broadcast_channel_provider)
     : partition_path_(partition_path),
       quota_manager_(quota_manager),
       appcache_service_(appcache_service),
       filesystem_context_(filesystem_context),
       database_tracker_(database_tracker),
       dom_storage_context_(dom_storage_context),
       indexed_db_context_(indexed_db_context),
       cache_storage_context_(cache_storage_context),
       service_worker_context_(service_worker_context),
-      webrtc_identity_store_(webrtc_identity_store),
       special_storage_policy_(special_storage_policy),
       host_zoom_level_context_(host_zoom_level_context),
       platform_notification_context_(platform_notification_context),
       background_sync_context_(background_sync_context),
       broadcast_channel_provider_(std::move(broadcast_channel_provider)),
       browser_context_(browser_context) {}
 
 StoragePartitionImpl::~StoragePartitionImpl() {
   browser_context_ = nullptr;
 
@@ skipping 92 matching lines @@
   cache_storage_context->Init(path, make_scoped_refptr(quota_manager->proxy()));
 
   scoped_refptr<ServiceWorkerContextWrapper> service_worker_context =
       new ServiceWorkerContextWrapper(context);
   service_worker_context->Init(path, quota_manager->proxy(),
                                context->GetSpecialStoragePolicy());
 
   scoped_refptr<ChromeAppCacheService> appcache_service =
       new ChromeAppCacheService(quota_manager->proxy());
 
-  scoped_refptr<WebRTCIdentityStore> webrtc_identity_store(
-      new WebRTCIdentityStore(path, context->GetSpecialStoragePolicy()));
-
   scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy(
       context->GetSpecialStoragePolicy());
 
   scoped_refptr<HostZoomLevelContext> host_zoom_level_context(
       new HostZoomLevelContext(
           context->CreateZoomLevelDelegate(partition_path)));
 
   scoped_refptr<PlatformNotificationContextImpl> platform_notification_context =
       new PlatformNotificationContextImpl(path, context,
                                           service_worker_context);
   platform_notification_context->Initialize();
 
   scoped_refptr<BackgroundSyncContext> background_sync_context =
       new BackgroundSyncContext();
   background_sync_context->Init(service_worker_context);
 
   scoped_refptr<webmessaging::BroadcastChannelProvider>
       broadcast_channel_provider = new webmessaging::BroadcastChannelProvider();
 
   StoragePartitionImpl* storage_partition = new StoragePartitionImpl(
       context, partition_path, quota_manager.get(), appcache_service.get(),
       filesystem_context.get(), database_tracker.get(),
       dom_storage_context.get(), indexed_db_context.get(),
       cache_storage_context.get(), service_worker_context.get(),
-      webrtc_identity_store.get(), special_storage_policy.get(),
-      host_zoom_level_context.get(), platform_notification_context.get(),
-      background_sync_context.get(), std::move(broadcast_channel_provider));
+      special_storage_policy.get(), host_zoom_level_context.get(),
+      platform_notification_context.get(), background_sync_context.get(),
+      std::move(broadcast_channel_provider));
 
   service_worker_context->set_storage_partition(storage_partition);
 
   return storage_partition;
 }
 
 base::FilePath StoragePartitionImpl::GetPath() {
   return partition_path_;
 }
 
@@ skipping 86 matching lines @@
     const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DataDeletionHelper* helper = new DataDeletionHelper(remove_mask,
                                                       quota_storage_remove_mask,
                                                       callback);
   // |helper| deletes itself when done in
   // DataDeletionHelper::DecrementTaskCountOnUI().
   helper->ClearDataOnUIThread(
       storage_origin, origin_matcher, cookie_matcher, GetPath(), rq_context,
       dom_storage_context_.get(), quota_manager_.get(),
-      special_storage_policy_.get(), webrtc_identity_store_.get(),
-      filesystem_context_.get(), begin, end);
+      special_storage_policy_.get(), filesystem_context_.get(), begin, end);
 }
 
 void StoragePartitionImpl::
     QuotaManagedDataDeletionHelper::IncrementTaskCountOnIO() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ++task_count;
 }
 
 void StoragePartitionImpl::
     QuotaManagedDataDeletionHelper::DecrementTaskCountOnIO() {
@@ skipping 118 matching lines @@
 
 void StoragePartitionImpl::DataDeletionHelper::ClearDataOnUIThread(
     const GURL& storage_origin,
     const OriginMatcherFunction& origin_matcher,
     const CookieMatcherFunction& cookie_matcher,
     const base::FilePath& path,
     net::URLRequestContextGetter* rq_context,
     DOMStorageContextWrapper* dom_storage_context,
     storage::QuotaManager* quota_manager,
     storage::SpecialStoragePolicy* special_storage_policy,
-    WebRTCIdentityStore* webrtc_identity_store,
     storage::FileSystemContext* filesystem_context,
     const base::Time begin,
     const base::Time end) {
   DCHECK_NE(remove_mask, 0u);
   DCHECK(!callback.is_null());
 
   IncrementTaskCountOnUI();
   base::Closure decrement_callback = base::Bind(
       &DataDeletionHelper::DecrementTaskCountOnUI, base::Unretained(this));
 
@@ skipping 49 matching lines @@
   }
 
   if (remove_mask & REMOVE_DATA_MASK_SHADER_CACHE) {
     IncrementTaskCountOnUI();
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&ClearShaderCacheOnIOThread,
                    path, begin, end, decrement_callback));
   }
 
-  if (remove_mask & REMOVE_DATA_MASK_WEBRTC_IDENTITY) {
-    IncrementTaskCountOnUI();
-    BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(&WebRTCIdentityStore::DeleteBetween,
-                   webrtc_identity_store,
-                   begin,
-                   end,
-                   decrement_callback));
-  }
-
 #if defined(ENABLE_PLUGINS)
   if (remove_mask & REMOVE_DATA_MASK_PLUGIN_PRIVATE_DATA) {
     IncrementTaskCountOnUI();
     filesystem_context->default_file_task_runner()->PostTask(
         FROM_HERE, base::Bind(&ClearPluginPrivateDataOnFileTaskRunner,
                               make_scoped_refptr(filesystem_context),
                               storage_origin, begin, end, decrement_callback));
   }
 #endif  // defined(ENABLE_PLUGINS)
 
@@ skipping 37 matching lines @@
   ClearDataImpl(remove_mask, quota_storage_remove_mask, GURL(), origin_matcher,
                 cookie_matcher, GetURLRequestContext(), begin, end, callback);
 }
 
 void StoragePartitionImpl::Flush() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (GetDOMStorageContext())
     GetDOMStorageContext()->Flush();
 }
 
-WebRTCIdentityStore* StoragePartitionImpl::GetWebRTCIdentityStore() {
-  return webrtc_identity_store_.get();
-}
-
 BrowserContext* StoragePartitionImpl::browser_context() const {
   return browser_context_;
 }
 
 void StoragePartitionImpl::Bind(
     mojo::InterfaceRequest<mojom::StoragePartitionService> request) {
   bindings_.AddBinding(this, std::move(request));
 }
 
 void StoragePartitionImpl::OverrideQuotaManagerForTesting(
@@ skipping 10 matching lines @@
     net::URLRequestContextGetter* url_request_context) {
   url_request_context_ = url_request_context;
 }
 
 void StoragePartitionImpl::SetMediaURLRequestContext(
     net::URLRequestContextGetter* media_url_request_context) {
   media_url_request_context_ = media_url_request_context;
 }
 
 }  // namespace content