Add ability to clear content licenses

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 18 matching lines @@
 #include "content/public/browser/session_storage_usage_info.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/database/database_tracker.h"
 #include "storage/browser/quota/quota_manager.h"
 
+#if defined(ENABLE_PLUGINS)
+#include "base/files/file_enumerator.h"
+#include "base/stl_util.h"
+#include "ppapi/shared_impl/ppapi_constants.h"
+#include "storage/browser/fileapi/async_file_util.h"
+#include "storage/browser/fileapi/async_file_util_adapter.h"
+#include "storage/browser/fileapi/isolated_context.h"
+#include "storage/browser/fileapi/obfuscated_file_util.h"
+#include "storage/common/fileapi/file_system_util.h"
+#endif  // defined(ENABLE_PLUGINS)
+
 namespace content {
 
 namespace {
 
 bool DoesCookieMatchHost(const std::string& host,
                          const net::CanonicalCookie& cookie) {
   return cookie.IsHostCookie() && cookie.IsDomainMatch(host);
 }
 
 void OnClearedCookies(const base::Closure& callback, int num_deleted) {
@@ skipping 159 matching lines @@
     const StoragePartition::OriginMatcherFunction& origin_matcher,
     const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   dom_storage_context->GetSessionStorageUsage(
       base::Bind(&OnSessionStorageUsageInfo, dom_storage_context,
                  special_storage_policy, origin_matcher,
                  callback));
 }
 
+#if defined(ENABLE_PLUGINS)
+// Helper for deleting plugin private data for a specified origin and plugin.
+// If any file matches the time range specified, then all files for this
+// origin and plugin are deleted.
+// All of the operations in this class are done on the FILE thread.
+class PluginPrivateDataByOriginDeletionHelper {
+ public:
+  PluginPrivateDataByOriginDeletionHelper(
+      storage::FileSystemContext* filesystem_context,
+      const GURL& origin,
+      const std::string& plugin_name,
+      const base::Time begin,
+      const base::Time end,
+      const base::Closure& callback)
+      : filesystem_context_(filesystem_context),
+        origin_(origin),
+        plugin_name_(plugin_name),
+        begin_(begin),
+        end_(end),
+        callback_(callback) {
+    // Create the filesystem ID.
+    fsid_ = storage::IsolatedContext::GetInstance()
+                ->RegisterFileSystemForVirtualPath(
+                    storage::kFileSystemTypePluginPrivate,
+                    ppapi::kPluginPrivateRootName, base::FilePath());
+  }
+  ~PluginPrivateDataByOriginDeletionHelper() {}
+
+  // Checks the files contained in the plugin private filesystem for |origin_|
+  // and |plugin_name_| and deletes any files whose last modified time is
+  // greater or equal to |begin_|. |callback_| is called when all actions
+  // are complete.
+  void Start();
+
+ private:
+  void OnFileSystemOpened(base::File::Error result);
+  void OnDirectoryRead(const std::string& root,
+                       base::File::Error result,
+                       const storage::AsyncFileUtil::EntryList& file_list,
+                       bool has_more);
+  void OnFileInfo(const std::string& file_name,
+                  base::File::Error result,
+                  const base::File::Info& file_info);
+
+  // Keeps track of the pending work. When |task_count_| goes to 0 then
+  // |callback_| is called and this helper object is destroyed.
+  void IncrementTaskCount();
+  void DecrementTaskCount();
+
+  // Not owned by this object. Caller is responsible for keeping the
+  // FileSystemContext alive until |callback_| is called.
+  storage::FileSystemContext* filesystem_context_;
+
+  const GURL origin_;
+  const std::string plugin_name_;
+  const base::Time begin_;
+  const base::Time end_;
+  const base::Closure callback_;
+  std::string fsid_;
+  int task_count_ = 0;
+  bool delete_this_origin_data_ = false;
+};
+
+void PluginPrivateDataByOriginDeletionHelper::Start() {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(storage::ValidateIsolatedFileSystemId(fsid_));
+
+  IncrementTaskCount();
+  filesystem_context_->OpenPluginPrivateFileSystem(
+      origin_, storage::kFileSystemTypePluginPrivate, fsid_, plugin_name_,
+      storage::OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT,
+      base::Bind(&PluginPrivateDataByOriginDeletionHelper::OnFileSystemOpened,
+                 base::Unretained(this)));
+}
+
+void PluginPrivateDataByOriginDeletionHelper::OnFileSystemOpened(
+    base::File::Error result) {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DVLOG(3) << "Opened filesystem for " << origin_ << ":" << plugin_name_
+           << ", result: " << result;
+
+  // If we can't open the directory, we can't delete files so simply return.
+  if (result != base::File::FILE_OK) {
+    DecrementTaskCount();
+    return;
+  }
+
+  storage::AsyncFileUtil* file_util = filesystem_context_->GetAsyncFileUtil(
+      storage::kFileSystemTypePluginPrivate);
+  std::string root = storage::GetIsolatedFileSystemRootURIString(
+      origin_, fsid_, ppapi::kPluginPrivateRootName);
+  std::unique_ptr<storage::FileSystemOperationContext> operation_context =
+      base::WrapUnique(
+          new storage::FileSystemOperationContext(filesystem_context_));
+  file_util->ReadDirectory(
+      std::move(operation_context), filesystem_context_->CrackURL(GURL(root)),
+      base::Bind(&PluginPrivateDataByOriginDeletionHelper::OnDirectoryRead,
+                 base::Unretained(this), root));
+}
+
+void PluginPrivateDataByOriginDeletionHelper::OnDirectoryRead(
+    const std::string& root,
+    base::File::Error result,
+    const storage::AsyncFileUtil::EntryList& file_list,
+    bool has_more) {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DVLOG(3) << __FUNCTION__ << " result: " << result
+           << ", #files: " << file_list.size();
+
+  // Quit if there is an error.
+  if (result != base::File::FILE_OK) {
+    DLOG(ERROR) << "Unable to read directory for " << origin_ << ":"
+                << plugin_name_;
+    DecrementTaskCount();
+    return;
+  }
+
+  // No error, process the files returned. No need to do this if we have
+  // already decided to delete all the data for this origin.
+  if (!delete_this_origin_data_) {
+    storage::AsyncFileUtil* file_util = filesystem_context_->GetAsyncFileUtil(
+        storage::kFileSystemTypePluginPrivate);
+    for (const auto& file : file_list) {
+      DVLOG(3) << __FUNCTION__ << " file: " << file.name;
+      DCHECK(!file.is_directory);  // Nested directories not implemented.
+
+      std::unique_ptr<storage::FileSystemOperationContext> operation_context =
+          base::WrapUnique(
+              new storage::FileSystemOperationContext(filesystem_context_));
+      storage::FileSystemURL file_url =
+          filesystem_context_->CrackURL(GURL(root + file.name));
+      IncrementTaskCount();
+      file_util->GetFileInfo(
+          std::move(operation_context), file_url,
+          storage::FileSystemOperation::GET_METADATA_FIELD_SIZE |
+              storage::FileSystemOperation::GET_METADATA_FIELD_LAST_MODIFIED,
+          base::Bind(&PluginPrivateDataByOriginDeletionHelper::OnFileInfo,
+                     base::Unretained(this), file.name));
+    }
+  }
+
+  // If there are more files in this directory, wait for the next call.
+  if (has_more)
+    return;
+
+  DecrementTaskCount();
+}
+
+void PluginPrivateDataByOriginDeletionHelper::OnFileInfo(
+    const std::string& file_name,
+    base::File::Error result,
+    const base::File::Info& file_info) {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+
+  if (result == base::File::FILE_OK) {
+    DVLOG(3) << __FUNCTION__ << " name: " << file_name
+             << ", size: " << file_info.size
+             << ", modified: " << file_info.last_modified;
+    if (file_info.last_modified >= begin_ && file_info.last_modified <= end_)
+      delete_this_origin_data_ = true;
+  }
+
+  DecrementTaskCount();
+}
+
+void PluginPrivateDataByOriginDeletionHelper::IncrementTaskCount() {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  ++task_count_;
+}
+
+void PluginPrivateDataByOriginDeletionHelper::DecrementTaskCount() {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK_GT(task_count_, 0);
+  --task_count_;
+  if (task_count_)
+    return;
+
+  // If there are no more tasks in progress, then delete the files for this
+  // origin if necessary.
+  if (delete_this_origin_data_) {
+    DVLOG(3) << "Deleting plugin data for " << origin_ << ":" << plugin_name_;
+    storage::FileSystemBackend* backend =
+        filesystem_context_->GetFileSystemBackend(
+            storage::kFileSystemTypePluginPrivate);
+    storage::FileSystemQuotaUtil* quota_util = backend->GetQuotaUtil();
+    base::File::Error result = quota_util->DeleteOriginDataOnFileTaskRunner(
+        filesystem_context_, nullptr, origin_,
+        storage::kFileSystemTypePluginPrivate);
+    DLOG_IF(ERROR, result != base::File::FILE_OK)
+        << "Unable to delete the plugin data for " << origin_ << ":"
+        << plugin_name_;
+  }
+
+  // Run |callback_| and then this helper can be deleted.
+  callback_.Run();
+  delete this;
+}
+
+// Helper for deleting the plugin private data.
+// All of the operations in this class are done on the FILE thread.
+class PluginPrivateDataDeletionHelper {
+ public:
+  PluginPrivateDataDeletionHelper(
+      scoped_refptr<storage::FileSystemContext> filesystem_context,
+      const base::Time begin,
+      const base::Time end,
+      const base::Closure& callback)
+      : filesystem_context_(std::move(filesystem_context)),
+        begin_(begin),
+        end_(end),
+        callback_(callback) {}
+  ~PluginPrivateDataDeletionHelper() {}
+
+  void CheckOrigins(const std::set<GURL>& origins);
+
+ private:
+  // Keeps track of the pending work. When |task_count_| goes to 0 then
+  // |callback_| is called and this helper object is destroyed.
+  void IncrementTaskCount();
+  void DecrementTaskCount();
+
+  // Keep a reference to FileSystemContext until we are done with it.
+  scoped_refptr<storage::FileSystemContext> filesystem_context_;
+
+  const base::Time begin_;
+  const base::Time end_;
+  const base::Closure callback_;
+  int task_count_ = 0;
+};
+
+void PluginPrivateDataDeletionHelper::CheckOrigins(
+    const std::set<GURL>& origins) {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  IncrementTaskCount();
+
+  base::Closure decrement_callback =
+      base::Bind(&PluginPrivateDataDeletionHelper::DecrementTaskCount,
+                 base::Unretained(this));
+  storage::AsyncFileUtil* async_file_util =
+      filesystem_context_->GetAsyncFileUtil(
+          storage::kFileSystemTypePluginPrivate);
+  storage::ObfuscatedFileUtil* obfuscated_file_util =
+      static_cast<storage::ObfuscatedFileUtil*>(
+          static_cast<storage::AsyncFileUtilAdapter*>(async_file_util)
+              ->sync_file_util());
+  for (const auto& origin : origins) {
+    // Determine the available plugin private filesystem directories
+    // for this origin.
+    base::File::Error error;
+    base::FilePath path = obfuscated_file_util->GetDirectoryForOriginAndType(
+        origin, "", false, &error);
+    if (error != base::File::FILE_OK) {
+      DLOG(ERROR) << "Unable to read directory for " << origin;
+      continue;
+    }
+
+    // Currently the plugin private filesystem is only used by Encrypted
+    // Media Content Decryption Modules, which are treated as pepper plugins.
+    // Each CDM gets a directory based on the mimetype (e.g. plugin
+    // application/x-ppapi-widevine-cdm uses directory
+    // application_x-ppapi-widevine-cdm). Enumerate through the set of
+    // directories so that data from any CDM used by this origin is deleted.
+    base::FileEnumerator file_enumerator(path, false,
+                                         base::FileEnumerator::DIRECTORIES);
+    for (base::FilePath plugin_path = file_enumerator.Next();
+         !plugin_path.empty(); plugin_path = file_enumerator.Next()) {
+      IncrementTaskCount();
+      PluginPrivateDataByOriginDeletionHelper* helper =
+          new PluginPrivateDataByOriginDeletionHelper(
+              filesystem_context_.get(), origin.GetOrigin(),
+              plugin_path.BaseName().MaybeAsASCII(), begin_, end_,
+              decrement_callback);
+      helper->Start();
+      // |helper| will delete itself when it is done.
+    }
+  }
+
+  // Cancels out the call to IncrementTaskCount() at the start of this method.
+  // If there are no origins specified then this will cause this helper to
+  // be destroyed.
+  DecrementTaskCount();
+}
+
+void PluginPrivateDataDeletionHelper::IncrementTaskCount() {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  ++task_count_;
+}
+
+void PluginPrivateDataDeletionHelper::DecrementTaskCount() {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK_GT(task_count_, 0);
+  --task_count_;
+  if (task_count_)
+    return;
+
+  // If there are no more tasks in progress, run |callback_| and then
+  // this helper can be deleted.
+  callback_.Run();
+  delete this;
+}
+
+void ClearPluginPrivateDataOnFileThread(
+    scoped_refptr<storage::FileSystemContext> filesystem_context,
+    const GURL& storage_origin,
+    const base::Time begin,
+    const base::Time end,
+    const base::Closure& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DVLOG(3) << "Clearing plugin data for origin: " << storage_origin;
+
+  storage::FileSystemBackend* backend =
+      filesystem_context->GetFileSystemBackend(
+          storage::kFileSystemTypePluginPrivate);
+  storage::FileSystemQuotaUtil* quota_util = backend->GetQuotaUtil();
+
+  // Determine the set of origins used.
+  std::set<GURL> origins;
+  quota_util->GetOriginsForTypeOnFileTaskRunner(
+      storage::kFileSystemTypePluginPrivate, &origins);
+
+  if (origins.empty()) {
+    // No origins, so nothing to do.
+    callback.Run();
+    return;
+  }
+
+  // If a specific origin is provided, then check that it is in the list
+  // returned and remove all the other origins.
+  if (!storage_origin.is_empty()) {
+    if (!ContainsKey(origins, storage_origin)) {
+      // Nothing matches, so nothing to do.
+      callback.Run();
+      return;
+    }
+
+    // List should only contain the one value that matches.
+    origins.clear();
+    origins.insert(storage_origin);
+  }
+
+  PluginPrivateDataDeletionHelper* helper = new PluginPrivateDataDeletionHelper(
+      std::move(filesystem_context), begin, end, callback);
+  helper->CheckOrigins(origins);
+  // |helper| will delete itself when all origins have been checked.
+}
+#endif  // defined(ENABLE_PLUGINS)
+
 }  // namespace
 
 // Static.
 int StoragePartitionImpl::GenerateQuotaClientMask(uint32_t remove_mask) {
   int quota_client_mask = 0;
 
   if (remove_mask & StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS)
     quota_client_mask |= storage::QuotaClient::kFileSystem;
   if (remove_mask & StoragePartition::REMOVE_DATA_MASK_WEBSQL)
     quota_client_mask |= storage::QuotaClient::kDatabase;
@@ skipping 81 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,
       const StoragePartition::OriginMatcherFunction& origin_matcher,
@@ skipping 299 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(), begin, end);
+      special_storage_policy_.get(), webrtc_identity_store_.get(),
+      filesystem_context_.get(), begin, end);
 }
 
 void StoragePartitionImpl::
     QuotaManagedDataDeletionHelper::IncrementTaskCountOnIO() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ++task_count;
 }
 
 void StoragePartitionImpl::
     QuotaManagedDataDeletionHelper::DecrementTaskCountOnIO() {
@@ skipping 119 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));
 
   if (remove_mask & REMOVE_DATA_MASK_COOKIES) {
@@ skipping 60 matching lines @@
     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();
+    BrowserThread::PostTask(

[kinuko, 2016/05/25 08:57:53]

Should this use filesystem_context->default_file_task_runner() rather than FILE
thread to avoid running in parallel with other filesystem tasks?

[jrummell, 2016/05/26 00:35:10]

This seems correct (as GetOriginsForTypeOnFileTaskRunner() and others are
called). However, it fails later on when trying to open the plugin private file
system. It appears that doesn't work on the file_task_runner, which is a
SequencedTaskRunner [1]. PluginPrivateFileSystemBackend::OpenPrivateFileSystem()
ultimately uses PostTaskAndReplyRelay, which expects to get a
ThreadTaskRunnerHandle [2].

So is the correct solution to switch to the FILE thread (or another thread?) to
open the file system, or have
PluginPrivateFileSystemBackend::OpenPrivateFileSystem() check if it's on the
file task runner and don't bother posting a task?

[1]
https://code.google.com/p/chromium/codesearch#chromium/src/content/browser/fi...
[2]
https://code.google.com/p/chromium/codesearch#chromium/src/base/threading/pos...

[jrummell, 2016/05/26 01:23:29]

I did some more looking at the code, and it looks like most of the operations on
the plugin private file system need to be done on a ThreadTaskRunner. So changed
to use the FILE thread when accessing the file system, but use FileTaskRunner
for getting and deleting based on the origin.

+        BrowserThread::FILE, FROM_HERE,
+        base::Bind(&ClearPluginPrivateDataOnFileThread,
+                   make_scoped_refptr(filesystem_context), storage_origin,
+                   begin, end, decrement_callback));
+  }
+#endif  // defined(ENABLE_PLUGINS)
+
   DecrementTaskCountOnUI();
 }
 
 void StoragePartitionImpl::ClearDataForOrigin(
     uint32_t remove_mask,
     uint32_t quota_storage_remove_mask,
     const GURL& storage_origin,
     net::URLRequestContextGetter* request_context_getter,
     const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 61 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