Add ability to clear content licenses

content/browser/plugin_private_storage_helper.cc

+// Copyright 2016 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/plugin_private_storage_helper.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <memory>
+#include <set>
+#include <string>
+
+#include "base/bind.h"
+#include "base/compiler_specific.h"
+#include "base/files/file.h"
+#include "base/files/file_enumerator.h"
+#include "base/files/file_path.h"
+#include "base/location.h"
+#include "base/logging.h"
+#include "base/stl_util.h"
+#include "base/strings/utf_string_conversions.h"
+#include "content/public/browser/browser_thread.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/file_system_context.h"
+#include "storage/browser/fileapi/isolated_context.h"
+#include "storage/browser/fileapi/obfuscated_file_util.h"
+#include "storage/common/fileapi/file_system_util.h"
+
+namespace content {
+
+namespace {
+
+std::string StringTypeToString(const base::FilePath::StringType& value) {
+#if defined(OS_POSIX)
+  return value;
+#elif defined(OS_WIN)
+  return base::WideToUTF8(value);
+#endif
+}
+
+// Helper for checking the plugin private data for a specified origin and
+// plugin for the existance of any file that matches the time range specified.
+// All of the operations in this class are done on the IO thread.
+//
+// This class keeps track of outstanding async requests it generates, and does
+// not call |callback_| until they all respond (and thus don't need to worry
+// about lifetime of |this| in the async requests). If the data for the origin
+// needs to be deleted, it needs to be done on the file task runner, so we
+// want to ensure that there are no pending requests that may prevent the
+// date from being deleted.
+class PluginPrivateDataByOriginChecker {
+ public:
+  PluginPrivateDataByOriginChecker(
+      storage::FileSystemContext* filesystem_context,
+      const GURL& origin,
+      const std::string& plugin_name,
+      const base::Time begin,
+      const base::Time end,
+      const base::Callback<void(bool, const GURL&)>& 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());
+  }
+  ~PluginPrivateDataByOriginChecker() {}
+
+  // Checks the files contained in the plugin private filesystem for |origin_|
+  // and |plugin_name_| for any file whose last modified time is between
+  // |begin_| and |end_|. |callback_| is called when all actions are complete
+  // with true and the origin if any such file is found, false and empty GURL
+  // otherwise.
+  void CheckFilesOnIOThread();
+
+ 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::Callback<void(bool, const GURL&)> callback_;
+  std::string fsid_;
+  int task_count_ = 0;
+
+  // Keep track if the data for this origin needs to be deleted due to
+  // any file found that has last modified time between |begin_| and |end_|.
+  bool delete_this_origin_data_ = false;
+};
+
+void PluginPrivateDataByOriginChecker::CheckFilesOnIOThread() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(storage::ValidateIsolatedFileSystemId(fsid_));
+
+  IncrementTaskCount();
+  filesystem_context_->OpenPluginPrivateFileSystem(
+      origin_, storage::kFileSystemTypePluginPrivate, fsid_, plugin_name_,
+      storage::OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT,
+      base::Bind(&PluginPrivateDataByOriginChecker::OnFileSystemOpened,
+                 base::Unretained(this)));
+}
+
+void PluginPrivateDataByOriginChecker::OnFileSystemOpened(
+    base::File::Error result) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  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(&PluginPrivateDataByOriginChecker::OnDirectoryRead,
+                 base::Unretained(this), root));
+}
+
+void PluginPrivateDataByOriginChecker::OnDirectoryRead(
+    const std::string& root,
+    base::File::Error result,
+    const storage::AsyncFileUtil::EntryList& file_list,
+    bool has_more) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  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 + StringTypeToString(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(&PluginPrivateDataByOriginChecker::OnFileInfo,
+                     base::Unretained(this), StringTypeToString(file.name)));
+    }
+  }
+
+  // If there are more files in this directory, wait for the next call.
+  if (has_more)
+    return;
+
+  DecrementTaskCount();
+}
+
+void PluginPrivateDataByOriginChecker::OnFileInfo(
+    const std::string& file_name,
+    base::File::Error result,
+    const base::File::Info& file_info) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  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 PluginPrivateDataByOriginChecker::IncrementTaskCount() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  ++task_count_;
+}
+
+void PluginPrivateDataByOriginChecker::DecrementTaskCount() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK_GT(task_count_, 0);
+  --task_count_;
+  if (task_count_)
+    return;
+
+  // If there are no more tasks in progress, then run |callback_| on the
+  // proper thread.
+  filesystem_context_->default_file_task_runner()->PostTask(
+      FROM_HERE, base::Bind(callback_, delete_this_origin_data_, origin_));
+  delete this;
+}
+
+// Helper for deleting the plugin private data.
+// All of the operations in this class are done on the file task runner.
+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 CheckOriginsOnFileTaskRunner(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(bool delete_data_for_origin, const GURL& origin);
+
+  // 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::CheckOriginsOnFileTaskRunner(
+    const std::set<GURL>& origins) {
+  DCHECK(filesystem_context_->default_file_task_runner()
+             ->RunsTasksOnCurrentThread());
+  IncrementTaskCount();
+
+  base::Callback<void(bool, const GURL&)> 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();
+      PluginPrivateDataByOriginChecker* helper =
+          new PluginPrivateDataByOriginChecker(
+              filesystem_context_.get(), origin.GetOrigin(),
+              plugin_path.BaseName().MaybeAsASCII(), begin_, end_,
+              decrement_callback);
+      BrowserThread::PostTask(
+          BrowserThread::IO, FROM_HERE,
+          base::Bind(&PluginPrivateDataByOriginChecker::CheckFilesOnIOThread,
+                     base::Unretained(helper)));
+
+      // |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(false, GURL());
+}
+
+void PluginPrivateDataDeletionHelper::IncrementTaskCount() {
+  DCHECK(filesystem_context_->default_file_task_runner()
+             ->RunsTasksOnCurrentThread());
+  ++task_count_;
+}
+
+void PluginPrivateDataDeletionHelper::DecrementTaskCount(
+    bool delete_data_for_origin,
+    const GURL& origin) {
+  DCHECK(filesystem_context_->default_file_task_runner()
+             ->RunsTasksOnCurrentThread());
+
+  // Since the PluginPrivateDataByOriginChecker runs on the IO thread,
+  // delete all the data for |origin| if needed.
+  if (delete_data_for_origin) {
+    DCHECK(!origin.is_empty());
+    DVLOG(3) << "Deleting plugin data for " << origin;
+    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);
+    ALLOW_UNUSED_LOCAL(result);
+    DLOG_IF(ERROR, result != base::File::FILE_OK)
+        << "Unable to delete the plugin data for " << origin;
+  }
+
+  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;
+}
+
+}  // namespace
+
+void ClearPluginPrivateDataOnFileTaskRunner(
+    scoped_refptr<storage::FileSystemContext> filesystem_context,
+    const GURL& storage_origin,
+    const base::Time begin,
+    const base::Time end,
+    const base::Closure& callback) {
+  DCHECK(filesystem_context->default_file_task_runner()
+             ->RunsTasksOnCurrentThread());
+  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->CheckOriginsOnFileTaskRunner(origins);
+  // |helper| will delete itself when all origins have been checked.
+}
+
+}  // namespace content