Clear data for origin if no files found

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 263 matching lines @@
     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);
   }
 
+  void DeleteClearKeyTestData() { DeleteFile(clearkey_file_); }
+
   // 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();
@@ skipping 60 matching lines @@
     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;
   }
 
+  void DeleteFile(storage::FileSystemURL file_url) {
+    AwaitCompletionHelper await_completion;
+    storage::AsyncFileUtil* file_util = filesystem_context_->GetAsyncFileUtil(
+        storage::kFileSystemTypePluginPrivate);
+    std::unique_ptr<storage::FileSystemOperationContext> operation_context =
+        base::MakeUnique<storage::FileSystemOperationContext>(
+            filesystem_context_);
+    file_util->DeleteFile(
+        std::move(operation_context), file_url,
+        base::Bind(&RemovePluginPrivateDataTester::OnFileDeleted,
+                   base::Unretained(this), &await_completion));
+    await_completion.BlockUntilNotified();
+  }
+
   // 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::MakeUnique<storage::FileSystemOperationContext>(
             filesystem_context_);
@@ skipping 11 matching lines @@
   }
 
   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 OnFileDeleted(AwaitCompletionHelper* await_completion,
+                     base::File::Error result) {
+    EXPECT_EQ(base::File::FILE_OK, result) << base::File::ErrorToString(result);
+    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) {
@@ skipping 21 matching lines @@
     // 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.
+  // Keep track of the URL for the ClearKey file so that it can be written to
+  // or deleted.
   storage::FileSystemURL clearkey_file_;
 
   DISALLOW_COPY_AND_ASSIGN(RemovePluginPrivateDataTester);
 };
 #endif  // BUILDFLAG(ENABLE_PLUGINS)
 
 bool IsWebSafeSchemeForTest(const std::string& scheme) {
   return scheme == "http";
 }
 
@@ skipping 839 matching lines @@
   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());
 }
+
+TEST_F(StoragePartitionImplTest, RemovePluginPrivateDataAfterDeletion) {
+  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));
+
+  // Delete the single file saved for |kOrigin1|. This does not remove the
+  // origin from the list of Origins. However, ClearPluginPrivateData() will
+  // remove it.
+  tester.DeleteClearKeyTestData();
+  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));
+}
 #endif  // BUILDFLAG(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);
@@ skipping 11 matching lines @@
       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