Beginnings of synchronizing notifications in the notification database.

content/browser/notifications/platform_notification_context_unittest.cc

 // Copyright 2015 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 "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/run_loop.h"
 #include "content/browser/notifications/platform_notification_context_impl.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/public/browser/notification_database_data.h"
+#include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace content {
 
 // Fake render process id to use in tests requiring one.
 const int kFakeRenderProcessId = 99;
 
 // Fake Service Worker registration id to use in tests requiring one.
@@ skipping 55 matching lines @@
     success_ = success;
     *store_notification_datas = notification_datas;
   }
 
  protected:
   // Creates a new PlatformNotificationContextImpl instance. When using this
   // method, the underlying database will always be created in memory. The
   // current message loop proxy will be used as the task runner.
   PlatformNotificationContextImpl* CreatePlatformNotificationContext() {
     PlatformNotificationContextImpl* context =
-        new PlatformNotificationContextImpl(base::FilePath(), nullptr);
+        new PlatformNotificationContextImpl(base::FilePath(),
+                                            &browser_context_,
+                                            nullptr);
     context->Initialize();
 
     OverrideTaskRunnerForTesting(context);
     return context;
   }
 
   // Overrides the task runner in |context| with the current message loop
   // proxy, to reduce the number of threads involved in the tests.
   void OverrideTaskRunnerForTesting(PlatformNotificationContextImpl* context) {
     context->SetTaskRunnerForTesting(base::MessageLoopProxy::current());
   }
 
+  // Returns the testing browsing context that can be used for this test.
+  BrowserContext* browser_context() { return &browser_context_; }
+
   // Returns whether the last invoked callback finished successfully.
   bool success() const { return success_; }
 
   // Returns the NotificationDatabaseData associated with the last invoked
   // ReadNotificationData callback.
   const NotificationDatabaseData& database_data() const {
     return database_data_;
   }
 
   // Returns the notification id of the notification last written.
   int64_t notification_id() const { return notification_id_; }
 
  private:
   TestBrowserThreadBundle thread_bundle_;
+  TestBrowserContext browser_context_;
 
   bool success_;
   NotificationDatabaseData database_data_;
   int64_t notification_id_;
 };
 
 TEST_F(PlatformNotificationContextTest, ReadNonExistentNotification) {
   scoped_refptr<PlatformNotificationContextImpl> context =
       CreatePlatformNotificationContext();
 
@@ skipping 107 matching lines @@
 
 TEST_F(PlatformNotificationContextTest, ServiceWorkerUnregistered) {
   scoped_ptr<EmbeddedWorkerTestHelper> embedded_worker_test_helper(
       new EmbeddedWorkerTestHelper(base::FilePath(), kFakeRenderProcessId));
 
   // Manually create the PlatformNotificationContextImpl so that the Service
   // Worker context wrapper can be passed in.
   scoped_refptr<PlatformNotificationContextImpl> notification_context(
       new PlatformNotificationContextImpl(
           base::FilePath(),
+          browser_context(),
           embedded_worker_test_helper->context_wrapper()));
   notification_context->Initialize();
 
   OverrideTaskRunnerForTesting(notification_context.get());
 
   GURL origin("https://example.com");
   GURL script_url("https://example.com/worker.js");
 
   int64_t service_worker_registration_id = kInvalidServiceWorkerRegistrationId;
 
@@ skipping 83 matching lines @@
   EXPECT_FALSE(success());
 }
 
 TEST_F(PlatformNotificationContextTest, DestroyOnDiskDatabase) {
   base::ScopedTempDir database_dir;
   ASSERT_TRUE(database_dir.CreateUniqueTempDir());
 
   // Manually construct the PlatformNotificationContextImpl because this test
   // requires the database to be created on the filesystem.
   scoped_refptr<PlatformNotificationContextImpl> context(
-      new PlatformNotificationContextImpl(database_dir.path(), nullptr));
+      new PlatformNotificationContextImpl(database_dir.path(),
+                                          browser_context(),
+                                          nullptr));
 
   OverrideTaskRunnerForTesting(context.get());
 
   // Trigger a read-operation to force creating the database.
   context->ReadNotificationData(
       42 /* notification_id */,
       GURL("https://example.com"),
       base::Bind(&PlatformNotificationContextTest::DidReadNotificationData,
                  base::Unretained(this)));
 
@@ skipping 72 matching lines @@
   ASSERT_EQ(10u, notification_database_datas.size());
 
   for (int i = 0; i < 10; ++i) {
     EXPECT_EQ(origin, notification_database_datas[i].origin);
     EXPECT_EQ(kFakeServiceWorkerRegistrationId,
               notification_database_datas[i].service_worker_registration_id);
   }
 }
 
 }  // namespace content