Add ability to clear content licenses

content/browser/storage_partition_impl_unittest.cc

 // Copyright 2013 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 <stddef.h>
 #include <stdint.h>
 
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
@@ skipping 12 matching lines @@
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/base/test_completion_callback.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_store.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/quota/quota_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#if defined(ENABLE_PLUGINS)
+#include "ppapi/shared_impl/ppapi_constants.h"
+#include "storage/browser/fileapi/async_file_util.h"
+#include "storage/browser/fileapi/file_system_context.h"
+#include "storage/browser/fileapi/file_system_operation_context.h"
+#include "storage/browser/fileapi/isolated_context.h"
+#include "storage/common/fileapi/file_system_util.h"
+#endif  // defined(ENABLE_PLUGINS)
+
 using net::CanonicalCookie;
 
 namespace content {
 namespace {
 
 const int kDefaultClientId = 42;
 const char kCacheKey[] = "key";
 const char kCacheValue[] = "cached value";
 
 const char kTestOrigin1[] = "http://host1:1/";
 const char kTestOrigin2[] = "http://host2:1/";
 const char kTestOrigin3[] = "http://host3:1/";
 const char kTestOriginDevTools[] = "chrome-devtools://abcdefghijklmnopqrstuvw/";
 
+#if defined(ENABLE_PLUGINS)
+const char kWidevineCdmPluginId[] = "application_x-ppapi-widevine-cdm";
+const char kClearKeyCdmPluginId[] = "application_x-ppapi-clearkey-cdm";
+#endif  // defined(ENABLE_PLUGINS)
+
 const GURL kOrigin1(kTestOrigin1);
 const GURL kOrigin2(kTestOrigin2);
 const GURL kOrigin3(kTestOrigin3);
 const GURL kOriginDevTools(kTestOriginDevTools);
 
 const base::FilePath::CharType kDomStorageOrigin1[] =
     FILE_PATH_LITERAL("http_host1_1.localstorage");
 
 const base::FilePath::CharType kDomStorageOrigin2[] =
     FILE_PATH_LITERAL("http_host2_1.localstorage");
@@ skipping 167 matching lines @@
   TestBrowserContext* profile_;
   content::DOMStorageContext* dom_storage_context_;
 
   std::vector<content::LocalStorageUsageInfo> infos_;
 
   AwaitCompletionHelper await_completion_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoveLocalStorageTester);
 };
 
+#if defined(ENABLE_PLUGINS)
+class RemovePluginPrivateDataTester {
+ public:
+  explicit RemovePluginPrivateDataTester(
+      storage::FileSystemContext* filesystem_context)
+      : filesystem_context_(filesystem_context) {}
+
+  // Add some files to the PluginPrivateFileSystem. They are created as follows:
+  //   kOrigin1 - ClearKey - 1 file - timestamp 10 days ago
+  //   kOrigin2 - Widevine - 2 files - timestamps now and 60 days ago
+  void AddPluginPrivateTestData() {
+    base::Time now = base::Time::Now();
+    base::Time ten_days_ago = now - base::TimeDelta::FromDays(10);
+    base::Time sixty_days_ago = now - base::TimeDelta::FromDays(60);
+
+    // Create a PluginPrivateFileSystem for ClearKey and add a single file
+    // with a timestamp of 1 day ago.
+    std::string clearkey_fsid =
+        CreateFileSystem(kClearKeyCdmPluginId, kOrigin1);
+    clearkey_file_ = CreateFile(kOrigin1, clearkey_fsid, "foo");
+    SetFileTimestamp(clearkey_file_, ten_days_ago);
+
+    // Create a second PluginPrivateFileSystem for Widevine and add two files
+    // with different times.
+    std::string widevine_fsid =
+        CreateFileSystem(kWidevineCdmPluginId, kOrigin2);
+    storage::FileSystemURL widevine_file1 =
+        CreateFile(kOrigin2, widevine_fsid, "bar1");
+    storage::FileSystemURL widevine_file2 =
+        CreateFile(kOrigin2, widevine_fsid, "bar2");
+    SetFileTimestamp(widevine_file1, now);
+    SetFileTimestamp(widevine_file2, sixty_days_ago);
+  }
+
+  // Returns true, if the given origin exists in a PluginPrivateFileSystem.
+  bool DataExistsForOrigin(const GURL& origin) {
+    AwaitCompletionHelper await_completion;
+    bool data_exists_for_origin = false;
+    filesystem_context_->default_file_task_runner()->PostTask(
+        FROM_HERE, base::Bind(&RemovePluginPrivateDataTester::
+                                  CheckIfDataExistsForOriginOnFileTaskRunner,
+                              base::Unretained(this), origin,
+                              &data_exists_for_origin, &await_completion));
+    await_completion.BlockUntilNotified();
+    return data_exists_for_origin;
+  }
+
+  // Opens the file created for ClearKey (in kOrigin1) for writing. Caller
+  // needs to verify if the file was opened or not.
+  base::File OpenClearKeyFileForWrite() {
+    AwaitCompletionHelper await_completion;
+    base::File file;
+    storage::AsyncFileUtil* async_file_util =
+        filesystem_context_->GetAsyncFileUtil(
+            storage::kFileSystemTypePluginPrivate);
+    std::unique_ptr<storage::FileSystemOperationContext> operation_context =
+        base::WrapUnique(
+            new storage::FileSystemOperationContext(filesystem_context_));
+    async_file_util->CreateOrOpen(
+        std::move(operation_context), clearkey_file_,
+        base::File::FLAG_OPEN | base::File::FLAG_WRITE,
+        base::Bind(&RemovePluginPrivateDataTester::OnFileOpened,
+                   base::Unretained(this), &file, &await_completion));
+    await_completion.BlockUntilNotified();
+    return file;
+  }
+
+ private:
+  // Creates a PluginPrivateFileSystem for the |plugin_name| and |origin|
+  // provided. Returns the file system ID for the created
+  // PluginPrivateFileSystem.
+  std::string CreateFileSystem(const std::string& plugin_name,
+                               const GURL& origin) {
+    AwaitCompletionHelper await_completion;
+    std::string fsid = storage::IsolatedContext::GetInstance()
+                           ->RegisterFileSystemForVirtualPath(
+                               storage::kFileSystemTypePluginPrivate,
+                               ppapi::kPluginPrivateRootName, base::FilePath());
+    EXPECT_TRUE(storage::ValidateIsolatedFileSystemId(fsid));
+    filesystem_context_->OpenPluginPrivateFileSystem(
+        origin, storage::kFileSystemTypePluginPrivate, fsid, plugin_name,
+        storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+        base::Bind(&RemovePluginPrivateDataTester::OnFileSystemOpened,
+                   base::Unretained(this), &await_completion));
+    await_completion.BlockUntilNotified();
+    return fsid;
+  }
+
+  // Creates a file named |file_name| in the PluginPrivateFileSystem identified
+  // by |origin| and |fsid|. Returns the URL for the created file. The file
+  // must not already exist or the test will fail.
+  storage::FileSystemURL CreateFile(const GURL& origin,
+                                    const std::string& fsid,
+                                    const std::string& file_name) {
+    AwaitCompletionHelper await_completion;
+    std::string root = storage::GetIsolatedFileSystemRootURIString(
+        origin, fsid, ppapi::kPluginPrivateRootName);
+    storage::FileSystemURL file_url =
+        filesystem_context_->CrackURL(GURL(root + file_name));
+    storage::AsyncFileUtil* file_util = filesystem_context_->GetAsyncFileUtil(
+        storage::kFileSystemTypePluginPrivate);
+    std::unique_ptr<storage::FileSystemOperationContext> operation_context =
+        base::WrapUnique(
+            new storage::FileSystemOperationContext(filesystem_context_));
+    operation_context->set_allowed_bytes_growth(
+        storage::QuotaManager::kNoLimit);
+    file_util->EnsureFileExists(
+        std::move(operation_context), file_url,
+        base::Bind(&RemovePluginPrivateDataTester::OnFileCreated,
+                   base::Unretained(this), &await_completion));
+    await_completion.BlockUntilNotified();
+    return file_url;
+  }
+
+  // Sets the last_access_time and last_modified_time to |time_stamp| on the
+  // file specified by |file_url|. The file must already exist.
+  void SetFileTimestamp(const storage::FileSystemURL& file_url,
+                        const base::Time& time_stamp) {
+    AwaitCompletionHelper await_completion;
+    storage::AsyncFileUtil* file_util = filesystem_context_->GetAsyncFileUtil(
+        storage::kFileSystemTypePluginPrivate);
+    std::unique_ptr<storage::FileSystemOperationContext> operation_context =
+        base::WrapUnique(
+            new storage::FileSystemOperationContext(filesystem_context_));
+    file_util->Touch(std::move(operation_context), file_url, time_stamp,
+                     time_stamp,
+                     base::Bind(&RemovePluginPrivateDataTester::OnFileTouched,
+                                base::Unretained(this), &await_completion));
+    await_completion.BlockUntilNotified();
+  }
+
+  void OnFileSystemOpened(AwaitCompletionHelper* await_completion,
+                          base::File::Error result) {
+    EXPECT_EQ(base::File::FILE_OK, result) << base::File::ErrorToString(result);
+    await_completion->Notify();
+  }
+
+  void OnFileCreated(AwaitCompletionHelper* await_completion,
+                     base::File::Error result,
+                     bool created) {
+    EXPECT_EQ(base::File::FILE_OK, result) << base::File::ErrorToString(result);
+    EXPECT_TRUE(created);
+    await_completion->Notify();
+  }
+
+  void OnFileTouched(AwaitCompletionHelper* await_completion,
+                     base::File::Error result) {
+    EXPECT_EQ(base::File::FILE_OK, result) << base::File::ErrorToString(result);
+    await_completion->Notify();
+  }
+
+  void OnFileOpened(base::File* file_result,
+                    AwaitCompletionHelper* await_completion,
+                    base::File file,
+                    const base::Closure& on_close_callback) {
+    *file_result = std::move(file);
+    await_completion->Notify();
+  }
+
+  // If |origin| exists in the PluginPrivateFileSystem, set
+  // |data_exists_for_origin| to true, false otherwise.
+  void CheckIfDataExistsForOriginOnFileTaskRunner(
+      const GURL& origin,
+      bool* data_exists_for_origin,
+      AwaitCompletionHelper* await_completion) {
+    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);
+    *data_exists_for_origin = origins.find(origin) != origins.end();
+
+    // AwaitCompletionHelper and MessageLoop don't work on a
+    // SequencedTaskRunner, so post a task on the IO thread.
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                            base::Bind(&AwaitCompletionHelper::Notify,
+                                       base::Unretained(await_completion)));
+  }
+
+  // We don't own this pointer.
+  storage::FileSystemContext* filesystem_context_;
+
+  // Keep track of the URL for the ClearKey file so that it can be written to.
+  storage::FileSystemURL clearkey_file_;
+
+  DISALLOW_COPY_AND_ASSIGN(RemovePluginPrivateDataTester);
+};
+#endif  // defined(ENABLE_PLUGINS)
+
 bool IsWebSafeSchemeForTest(const std::string& scheme) {
   return scheme == "http";
 }
 
 bool DoesOriginMatchForUnprotectedWeb(
     const GURL& origin,
     storage::SpecialStoragePolicy* special_storage_policy) {
   if (IsWebSafeSchemeForTest(origin.scheme()))
     return !special_storage_policy->IsStorageProtected(origin.GetOrigin());
 
@@ skipping 93 matching lines @@
 void ClearData(content::StoragePartition* partition,
                base::RunLoop* run_loop) {
   base::Time time;
   partition->ClearData(
       StoragePartition::REMOVE_DATA_MASK_SHADER_CACHE,
       StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL,
       GURL(), StoragePartition::OriginMatcherFunction(),
       time, time, run_loop->QuitClosure());
 }
 
+#if defined(ENABLE_PLUGINS)
+void ClearPluginPrivateData(content::StoragePartition* partition,
+                            const GURL& storage_origin,
+                            const base::Time delete_begin,
+                            const base::Time delete_end,
+                            base::RunLoop* run_loop) {
+  partition->ClearData(
+      StoragePartitionImpl::REMOVE_DATA_MASK_PLUGIN_PRIVATE_DATA,
+      StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL, storage_origin,
+      StoragePartition::OriginMatcherFunction(), delete_begin, delete_end,
+      run_loop->QuitClosure());
+}
+#endif  // defined(ENABLE_PLUGINS)
+
 }  // namespace
 
 class StoragePartitionImplTest : public testing::Test {
  public:
   StoragePartitionImplTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
-        browser_context_(new TestBrowserContext()) {
-  }
+        browser_context_(new TestBrowserContext()) {}
 
   MockQuotaManager* GetMockManager() {
     if (!quota_manager_.get()) {
       quota_manager_ = new MockQuotaManager(
           browser_context_->IsOffTheRecord(),
           browser_context_->GetPath(),
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO).get(),
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB).get(),
           browser_context_->GetSpecialStoragePolicy());
     }
@@ skipping 603 matching lines @@
                  base::Bind(&DoesOriginMatchForBothProtectedAndUnprotectedWeb),
                  &run_loop));
   run_loop.Run();
 
   // kOrigin1 and kOrigin2 do not have age more than a week.
   EXPECT_FALSE(tester.DOMStorageExistsForOrigin(kOrigin1));
   EXPECT_FALSE(tester.DOMStorageExistsForOrigin(kOrigin2));
   EXPECT_TRUE(tester.DOMStorageExistsForOrigin(kOrigin3));
 }
 
+#if defined(ENABLE_PLUGINS)
+TEST_F(StoragePartitionImplTest, RemovePluginPrivateDataForever) {
+  StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>(
+      BrowserContext::GetDefaultStoragePartition(browser_context()));
+
+  RemovePluginPrivateDataTester tester(partition->GetFileSystemContext());
+  tester.AddPluginPrivateTestData();
+  EXPECT_TRUE(tester.DataExistsForOrigin(kOrigin1));
+  EXPECT_TRUE(tester.DataExistsForOrigin(kOrigin2));
+
+  base::RunLoop run_loop;
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&ClearPluginPrivateData, partition, GURL(),
+                            base::Time(), base::Time::Max(), &run_loop));
+  run_loop.Run();
+
+  EXPECT_FALSE(tester.DataExistsForOrigin(kOrigin1));
+  EXPECT_FALSE(tester.DataExistsForOrigin(kOrigin2));
+}
+
+TEST_F(StoragePartitionImplTest, RemovePluginPrivateDataLastWeek) {
+  StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>(
+      BrowserContext::GetDefaultStoragePartition(browser_context()));
+  base::Time a_week_ago = base::Time::Now() - base::TimeDelta::FromDays(7);
+
+  RemovePluginPrivateDataTester tester(partition->GetFileSystemContext());
+  tester.AddPluginPrivateTestData();
+  EXPECT_TRUE(tester.DataExistsForOrigin(kOrigin1));
+  EXPECT_TRUE(tester.DataExistsForOrigin(kOrigin2));
+
+  base::RunLoop run_loop;
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&ClearPluginPrivateData, partition, GURL(),
+                            a_week_ago, base::Time::Max(), &run_loop));
+  run_loop.Run();
+
+  // Origin1 has 1 file from 10 days ago, so it should remain around.
+  // Origin2 has a current file, so it should be removed (even though the
+  // second file is much older).
+  EXPECT_TRUE(tester.DataExistsForOrigin(kOrigin1));
+  EXPECT_FALSE(tester.DataExistsForOrigin(kOrigin2));
+}
+
+TEST_F(StoragePartitionImplTest, RemovePluginPrivateDataForOrigin) {
+  StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>(
+      BrowserContext::GetDefaultStoragePartition(browser_context()));
+
+  RemovePluginPrivateDataTester tester(partition->GetFileSystemContext());
+  tester.AddPluginPrivateTestData();
+  EXPECT_TRUE(tester.DataExistsForOrigin(kOrigin1));
+  EXPECT_TRUE(tester.DataExistsForOrigin(kOrigin2));
+
+  base::RunLoop run_loop;
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&ClearPluginPrivateData, partition, kOrigin1,
+                            base::Time(), base::Time::Max(), &run_loop));
+  run_loop.Run();
+
+  // Only Origin1 should be deleted.
+  EXPECT_FALSE(tester.DataExistsForOrigin(kOrigin1));
+  EXPECT_TRUE(tester.DataExistsForOrigin(kOrigin2));
+}
+
+TEST_F(StoragePartitionImplTest, RemovePluginPrivateDataWhileWriting) {
+  StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>(
+      BrowserContext::GetDefaultStoragePartition(browser_context()));
+
+  RemovePluginPrivateDataTester tester(partition->GetFileSystemContext());
+  tester.AddPluginPrivateTestData();
+  EXPECT_TRUE(tester.DataExistsForOrigin(kOrigin1));
+  EXPECT_TRUE(tester.DataExistsForOrigin(kOrigin2));
+
+  const char test_data[] = {0, 1, 2, 3, 4, 5};
+  base::File file = tester.OpenClearKeyFileForWrite();
+  EXPECT_TRUE(file.IsValid());
+  EXPECT_EQ(static_cast<int>(arraysize(test_data)),
+            file.Write(0, test_data, arraysize(test_data)));
+
+  base::RunLoop run_loop;
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&ClearPluginPrivateData, partition, GURL(),
+                            base::Time(), base::Time::Max(), &run_loop));
+  run_loop.Run();

[xhwang, 2016/06/02 23:51:45]

This will finish all the deletion steps then quit the RunLoop. But what if we
call file.WriteAtCurrentPos() in between?

kinuko / nhiroki: What's the general guideline for preventing racing between
file read/write and deletion (e.g. from Clear Browsing Data)?

[jrummell, 2016/06/08 23:44:08]

The test does different things on different OSes (on Windows clear actually
fails (silently) as there is a file open, on Linux it doesn't complain). So
Open()->Write()->Write() does succeed even if clearing happens between the
writes. However, this doesn't test what happens if the clearing pattern
(ReadDirectory()->CheckFile()->CheckFile()->...->DeleteDirectory()) is
interrupted by other actions affecting the files for that domain.

kinuko / nhiroki: Is the expectation that each step is sufficiently independent
so that file corruption doesn't happen?

[nhiroki, 2016/06/09 15:59:48]

Yes. Each operation is independent and able to finish without interruptions, so
I think file corruption should not happen unless each operation leaves a file
half-done.

+
+  EXPECT_FALSE(tester.DataExistsForOrigin(kOrigin1));
+  EXPECT_FALSE(tester.DataExistsForOrigin(kOrigin2));
+
+  const char more_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+  EXPECT_EQ(static_cast<int>(arraysize(more_data)),
+            file.WriteAtCurrentPos(more_data, arraysize(more_data)));
+
+  base::File file2 = tester.OpenClearKeyFileForWrite();
+  EXPECT_FALSE(file2.IsValid());
+}
+#endif  // defined(ENABLE_PLUGINS)
+
 TEST(StoragePartitionImplStaticTest, CreatePredicateForHostCookies) {
   GURL url("http://www.example.com/");
   GURL url2("https://www.example.com/");
   GURL url3("https://www.google.com/");
 
   net::CookieOptions options;
   net::CookieStore::CookiePredicate predicate =
       StoragePartitionImpl::CreatePredicateForHostCookies(url);
 
   base::Time now = base::Time::Now();
   std::vector<std::unique_ptr<CanonicalCookie>> valid_cookies;
   valid_cookies.push_back(CanonicalCookie::Create(url, "A=B", now, options));
   valid_cookies.push_back(CanonicalCookie::Create(url, "C=F", now, options));
   // We should match a different scheme with the same host.
   valid_cookies.push_back(CanonicalCookie::Create(url2, "A=B", now, options));
 
   std::vector<std::unique_ptr<CanonicalCookie>> invalid_cookies;
   // We don't match domain cookies.
   invalid_cookies.push_back(
       CanonicalCookie::Create(url2, "A=B;domain=.example.com", now, options));
   invalid_cookies.push_back(CanonicalCookie::Create(url3, "A=B", now, options));
 
   for (const auto& cookie : valid_cookies)
     EXPECT_TRUE(predicate.Run(*cookie)) << cookie->DebugString();
   for (const auto& cookie : invalid_cookies)
     EXPECT_FALSE(predicate.Run(*cookie)) << cookie->DebugString();
 }
 
 }  // namespace content