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 15 matching lines @@
 #include "content/public/browser/dom_storage_context.h"
 #include "content/public/browser/indexed_db_context.h"
 #include "content/public/browser/local_storage_usage_info.h"
 #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 "ppapi/shared_impl/ppapi_constants.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 "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(
+      const scoped_refptr<storage::FileSystemContext>& filesystem_context,

[nhiroki, 2016/05/23 05:07:51]

Passing "const scoped_refptr<Foo>&" is not encouraged:

"What about passing or returning a smart pointer by reference"
http://www.chromium.org/developers/smart-pointer-guidelines#TOC-What-about-pa...

[jrummell, 2016/05/23 22:25:36]

Done.

+      const GURL& origin,
+      const std::string& plugin_name,
+      const base::Time begin,
+      const base::Time end,
+      const base::Closure& callback)
+      : filesystem_context_(std::move(filesystem_context)),

[nhiroki, 2016/05/23 05:07:50]

IIUC, std::move for const-ref object does not move but copy. Maybe you should
change the first argument on the ctor to scoped_refptr<FSContext> (or to a
rawptr and then remove std::move() here).

[jrummell, 2016/05/23 22:25:35]

Converted to rawptr (and added a comment about ownership).

+        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,
+                  const storage::FileSystemURL& file_url,
+                  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();
+
+  scoped_refptr<storage::FileSystemContext> filesystem_context_;
+  GURL origin_;
+  std::string plugin_name_;
+  base::Time begin_;
+  base::Time end_;
+  base::Closure callback_;
+  std::string fsid_;
+  int task_count_ = 0;

[nhiroki, 2016/05/23 05:07:50]

In general, manual reference counting would be fragile. How about making this
helper class RefCounted and making each callback retain a reference to the
helper via the second arg of base::Bind?

[jrummell, 2016/05/23 22:25:36]

This is the pattern used by the other helpers in this file
(QuotaManagedDataDeletionHelper and DataDeletionHelper). Wouldn't RefCounted
depend on all the called functions not keeping the callback longer than
necessary?

[nhiroki, 2016/05/24 01:40:03]

Manual reference counting would also depend on lifetime of callbacks because
DecrementTaskCount() is called when a callback is completed.

I think lifetime of the helper is almost the same between manual reference
counting and RefCoutned. In manual reference counting, IncrementTaskCount() is
called when a callback is created and DecrementTaskCount() is called when the
callback is completed. In RefCounted, the internal refcount is incremented when
a callback is created and decremented when the callback is destroyed (slightly
after it's completed).

Anyway, I don't have strong opinions here. The current code looks correct and
it's consistent with other helpers. It's ok to land this as is.

+  bool delete_this_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_.get()));
+  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.
+  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_.get()));
+    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, file_url));
+  }
+
+  // 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,
+    const storage::FileSystemURL& file_url,

[nhiroki, 2016/05/23 05:07:50]

file_url is not used?

[jrummell, 2016/05/23 22:25:36]

Done.

+    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_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_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_.get(), 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(
+      const scoped_refptr<storage::FileSystemContext>& filesystem_context,

[nhiroki, 2016/05/23 05:07:50]

ditto (passing const scoped_refptr<>&).

[jrummell, 2016/05/23 22:25:36]

Done.

+      const base::Time begin,
+      const base::Time end,
+      const base::Closure& callback)
+      : filesystem_context_(std::move(filesystem_context)),

[nhiroki, 2016/05/23 05:07:51]

ditto (move for const-ref object).

[jrummell, 2016/05/23 22:25:36]

Done.

+        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();
+
+  scoped_refptr<storage::FileSystemContext> filesystem_context_;
+  base::Time begin_;
+  base::Time end_;
+  base::Closure callback_;
+  int task_count_ = 0;

[nhiroki, 2016/05/23 05:07:50]

ditto (manual reference counting)

[jrummell, 2016/05/23 22:25:35]

See previous comment.

+};
+
+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));
+  for (const auto& origin : origins) {
+    // Determine the available directories for this origin.
+    storage::AsyncFileUtil* async_file_util =
+        filesystem_context_->GetAsyncFileUtil(
+            storage::kFileSystemTypePluginPrivate);
+    storage::ObfuscatedFileUtil* obfuscated_file_util =

[jrummell, 2016/05/20 22:17:13]

This seems ugly (it's cloned from private
PluginPrivateFileSystemBackend::obfuscated_file_util()), but I can't find a
better way to get the ObfuscatedFileUtil object. Open to suggestions that avoid
casting, if one is possible.

+        static_cast<storage::ObfuscatedFileUtil*>(
+            static_cast<storage::AsyncFileUtilAdapter*>(async_file_util)
+                ->sync_file_util());

[nhiroki, 2016/05/23 05:07:51]

You could move these lines out of the for-loop.

[jrummell, 2016/05/23 22:25:36]

Done.

+    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;
+    }
+    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_, 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(
+    const scoped_refptr<storage::FileSystemContext>& filesystem_context,

[nhiroki, 2016/05/23 05:07:50]

Can you remove const-ref because the caller passes ownership of the context
using make_scoped_refptr.

[jrummell, 2016/05/23 22:25:35]

Done.

+    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()) {
+    auto it = origins.find(storage_origin);
+    if (it == origins.end()) {

[nhiroki, 2016/05/23 05:07:51]

Using ContainsKey in base/stl_util.h would be simpler.

  if (ContainsKey(origins, storage_origin))

[jrummell, 2016/05/23 22:25:36]

Done.

+      // 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(
+        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