[Background Fetch] Create DatabaseTask to get num requests by type

TBR=avi@chromium.org

Bug: 826257
Change-Id: I91ea969e3de8630365a115802ff6ed93901a1d00
Reviewed-on: https://chromium-review.googlesource.com/1066132
Commit-Queue: Rayan Kanso <rayankans@chromium.org>
Reviewed-by: Peter Beverloo <peter@chromium.org>
Cr-Commit-Position: refs/heads/master@{#561046}

content/browser/BUILD.gn

@@ -436,6 +436,8 @@ jumbo_source_set("browser") {
     "background_fetch/storage/get_developer_ids_task.h",
     "background_fetch/storage/get_metadata_task.cc",
     "background_fetch/storage/get_metadata_task.h",
+    "background_fetch/storage/get_num_requests_task.cc",
+    "background_fetch/storage/get_num_requests_task.h",
     "background_fetch/storage/get_settled_fetches_task.cc",
     "background_fetch/storage/get_settled_fetches_task.h",
     "background_fetch/storage/mark_registration_for_deletion_task.cc",

content/browser/background_fetch/background_fetch_data_manager.cc

@@ -19,6 +19,7 @@
 #include "content/browser/background_fetch/storage/delete_registration_task.h"
 #include "content/browser/background_fetch/storage/get_developer_ids_task.h"
 #include "content/browser/background_fetch/storage/get_metadata_task.h"
+#include "content/browser/background_fetch/storage/get_num_requests_task.h"
 #include "content/browser/background_fetch/storage/get_settled_fetches_task.h"
 #include "content/browser/background_fetch/storage/mark_registration_for_deletion_task.h"
 #include "content/browser/background_fetch/storage/mark_request_complete_task.h"
@@ -608,7 +609,9 @@ void BackgroundFetchDataManager::GetNumCompletedRequests(
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableBackgroundFetchPersistence)) {
-    // TODO(crbug.com/826257): Create database task to get number of requests.
+    AddDatabaseTask(std::make_unique<background_fetch::GetNumRequestsTask>(
+        this, registration_id, background_fetch::RequestType::kCompleted,
+        std::move(callback)));
     return;
   }
 

content/browser/background_fetch/background_fetch_data_manager_unittest.cc

@@ -18,6 +18,7 @@
 #include "content/browser/background_fetch/background_fetch_request_info.h"
 #include "content/browser/background_fetch/background_fetch_test_base.h"
 #include "content/browser/background_fetch/storage/database_helpers.h"
+#include "content/browser/background_fetch/storage/get_num_requests_task.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/public/browser/background_fetch_response.h"
 #include "content/public/browser/browser_thread.h"
@@ -263,7 +264,7 @@ class BackgroundFetchDataManagerTest
     run_loop.Run();
   }
 
-  // Synchronous version of ServiceWorkerContextWrapper::MarkRequestAsComplete.
+  // Synchronous version of BackgroundFetchDataManager::MarkRequestAsComplete().
   void MarkRequestAsComplete(
       const BackgroundFetchRegistrationId& registration_id,
       BackgroundFetchRequestInfo* request_info) {
@@ -297,6 +298,38 @@ class BackgroundFetchDataManagerTest
     run_loop.Run();
   }
 
+  // Synchronous version of
+  // BackgroundFetchDataManager::GetNumCompletedRequests().
+  void GetNumCompletedRequests(
+      const BackgroundFetchRegistrationId& registration_id,
+      size_t* out_size) {
+    DCHECK(out_size);
+
+    base::RunLoop run_loop;
+    background_fetch_data_manager_->GetNumCompletedRequests(
+        registration_id,
+        base::BindOnce(&BackgroundFetchDataManagerTest::DidGetNumRequests,
+                       base::Unretained(this), run_loop.QuitClosure(),
+                       out_size));
+    run_loop.Run();
+  }
+
+  // Synchronous version of GetNumRequestsTask::Start().
+  void GetNumRequestsTask(const BackgroundFetchRegistrationId& registration_id,
+                          background_fetch::RequestType type,
+                          size_t* out_size) {
+    DCHECK(out_size);
+
+    base::RunLoop run_loop;
+    background_fetch_data_manager_->AddDatabaseTask(
+        std::make_unique<background_fetch::GetNumRequestsTask>(
+            background_fetch_data_manager_.get(), registration_id, type,
+            base::BindOnce(&BackgroundFetchDataManagerTest::DidGetNumRequests,
+                           base::Unretained(this), run_loop.QuitClosure(),
+                           out_size)));
+    run_loop.Run();
+  }
+
   // Synchronous version of
   // ServiceWorkerContextWrapper::GetRegistrationUserDataByKeyPrefix.
   std::vector<std::string> GetRegistrationUserDataByKeyPrefix(
@@ -432,6 +465,13 @@ class BackgroundFetchDataManagerTest
     std::move(quit_closure).Run();
   }
 
+  void DidGetNumRequests(base::OnceClosure quit_closure,
+                         size_t* out_size,
+                         size_t size) {
+    *out_size = size;
+    std::move(quit_closure).Run();
+  }
+
   BackgroundFetchRegistrationStorage registration_storage_;
   std::unique_ptr<BackgroundFetchDataManager> background_fetch_data_manager_;
 };
@@ -877,6 +917,119 @@ TEST_P(BackgroundFetchDataManagerTest, GetSettledFetchesForRegistration) {
   EXPECT_EQ(settled_fetches.size(), requests.size());
 }
 
+TEST_P(BackgroundFetchDataManagerTest, GetNumCompletedRequests) {
+  int64_t sw_id = RegisterServiceWorker();
+  ASSERT_NE(blink::mojom::kInvalidServiceWorkerRegistrationId, sw_id);
+
+  BackgroundFetchRegistrationId registration_id(
+      sw_id, origin(), kExampleDeveloperId, kExampleUniqueId);
+
+  // The requests are default-initialized, but valid.
+  std::vector<ServiceWorkerFetchRequest> requests(2u);
+  BackgroundFetchOptions options;
+  blink::mojom::BackgroundFetchError error;
+
+  CreateRegistration(registration_id, requests, options, &error);
+
+  size_t num_completed = 0u;
+
+  GetNumCompletedRequests(registration_id, &num_completed);
+  EXPECT_EQ(num_completed, 0u);
+
+  scoped_refptr<BackgroundFetchRequestInfo> request_info;
+  // Download and store first request.
+  PopNextRequest(registration_id, &request_info);
+  ASSERT_TRUE(request_info);
+  AnnotateRequestInfoWithFakeDownloadManagerData(request_info.get());
+  MarkRequestAsComplete(registration_id, request_info.get());
+
+  GetNumCompletedRequests(registration_id, &num_completed);
+  EXPECT_EQ(num_completed, 1u);
+
+  RestartDataManagerFromPersistentStorage();
+
+  GetNumCompletedRequests(registration_id, &num_completed);
+  EXPECT_EQ(num_completed, 1u);
+
+  // Download and store second request.
+  PopNextRequest(registration_id, &request_info);
+  ASSERT_TRUE(request_info);
+  AnnotateRequestInfoWithFakeDownloadManagerData(request_info.get());
+  MarkRequestAsComplete(registration_id, request_info.get());
+
+  GetNumCompletedRequests(registration_id, &num_completed);
+  EXPECT_EQ(num_completed, 2u);
+}
+
+TEST_P(BackgroundFetchDataManagerTest, GetNumRequestsTask) {
+  // This test only applies to persistent storage.
+  if (registration_storage_ ==
+      BackgroundFetchRegistrationStorage::kNonPersistent)
+    return;
+
+  int64_t sw_id = RegisterServiceWorker();
+  ASSERT_NE(blink::mojom::kInvalidServiceWorkerRegistrationId, sw_id);
+
+  BackgroundFetchRegistrationId registration_id(
+      sw_id, origin(), kExampleDeveloperId, kExampleUniqueId);
+  BackgroundFetchOptions options;
+  blink::mojom::BackgroundFetchError error;
+
+  CreateRegistration(registration_id, {ServiceWorkerFetchRequest()}, options,
+                     &error);
+
+  size_t size = 0u;
+  GetNumRequestsTask(registration_id, background_fetch::RequestType::kAny,
+                     &size);
+  EXPECT_EQ(size, 1u);  // Total requests is 1.
+  GetNumRequestsTask(registration_id, background_fetch::RequestType::kPending,
+                     &size);
+  EXPECT_EQ(size, 1u);  // Total pending requests is 1.
+  GetNumRequestsTask(registration_id, background_fetch::RequestType::kActive,
+                     &size);
+  EXPECT_EQ(size, 0u);  // No active requests.
+  GetNumRequestsTask(registration_id, background_fetch::RequestType::kCompleted,
+                     &size);
+  EXPECT_EQ(size, 0u);  // No complete requests.
+
+  scoped_refptr<BackgroundFetchRequestInfo> request_info;
+  // Download and store first request.
+  PopNextRequest(registration_id, &request_info);
+  ASSERT_TRUE(request_info);
+
+  GetNumRequestsTask(registration_id, background_fetch::RequestType::kAny,
+                     &size);
+  EXPECT_EQ(size, 1u);  // Total requests is 1.
+  GetNumRequestsTask(registration_id, background_fetch::RequestType::kPending,
+                     &size);
+  EXPECT_EQ(size, 0u);  // Pending requests moved to active.
+  GetNumRequestsTask(registration_id, background_fetch::RequestType::kActive,
+                     &size);
+  EXPECT_EQ(size, 1u);  // Request is active.
+  GetNumRequestsTask(registration_id, background_fetch::RequestType::kCompleted,
+                     &size);
+  EXPECT_EQ(size, 0u);  // No complete requests.
+
+  AnnotateRequestInfoWithFakeDownloadManagerData(request_info.get());
+  MarkRequestAsComplete(registration_id, request_info.get());
+
+  GetNumRequestsTask(registration_id, background_fetch::RequestType::kActive,
+                     &size);
+  EXPECT_EQ(size, 0u);  // No active requests.
+  GetNumRequestsTask(registration_id, background_fetch::RequestType::kCompleted,
+                     &size);
+  EXPECT_EQ(size, 1u);  // Request is complete.
+
+  RestartDataManagerFromPersistentStorage();
+
+  GetNumRequestsTask(registration_id, background_fetch::RequestType::kCompleted,
+                     &size);
+  EXPECT_EQ(size, 1u);
+  GetNumRequestsTask(registration_id, background_fetch::RequestType::kAny,
+                     &size);
+  EXPECT_EQ(size, 1u);  // Total requests is still 1.
+}
+
 TEST_P(BackgroundFetchDataManagerTest, Cleanup) {
   // Tests that the BackgroundFetchDataManager cleans up registrations
   // marked for deletion.

content/browser/background_fetch/storage/get_num_requests_task.cc

+// Copyright 2018 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/background_fetch/storage/get_num_requests_task.h"
+
+#include "content/browser/background_fetch/background_fetch.pb.h"
+#include "content/browser/background_fetch/storage/database_helpers.h"
+#include "content/browser/background_fetch/storage/get_metadata_task.h"
+#include "content/browser/service_worker/service_worker_context_wrapper.h"
+
+namespace content {
+
+namespace background_fetch {
+
+namespace {
+
+void HandleGetMetadataCallback(
+    GetNumRequestsTask::NumRequestsCallback callback,
+    blink::mojom::BackgroundFetchError error,
+    std::unique_ptr<proto::BackgroundFetchMetadata> metadata) {
+  if (error != blink::mojom::BackgroundFetchError::NONE) {
+    std::move(callback).Run(0u);
+    return;
+  }
+
+  DCHECK(metadata);
+  std::move(callback).Run(metadata->num_fetches());
+}
+
+}  // namespace
+
+GetNumRequestsTask::GetNumRequestsTask(
+    BackgroundFetchDataManager* data_manager,
+    const BackgroundFetchRegistrationId& registration_id,
+    RequestType type,
+    NumRequestsCallback callback)
+    : DatabaseTask(data_manager),
+      registration_id_(registration_id),
+      type_(type),
+      callback_(std::move(callback)),
+      weak_factory_(this) {}
+
+GetNumRequestsTask::~GetNumRequestsTask() = default;
+
+void GetNumRequestsTask::Start() {
+  switch (type_) {
+    case RequestType::kAny:
+      GetMetadata();
+      return;
+    case RequestType::kPending:
+      GetRequests(PendingRequestKeyPrefix(registration_id_.unique_id()));
+      return;
+    case RequestType::kActive:
+      GetRequests(ActiveRequestKeyPrefix(registration_id_.unique_id()));
+      return;
+    case RequestType::kCompleted:
+      GetRequests(CompletedRequestKeyPrefix(registration_id_.unique_id()));
+      return;
+  }
+  NOTREACHED();
+}
+
+void GetNumRequestsTask::GetMetadata() {
+  AddDatabaseTask(std::make_unique<GetMetadataTask>(
+      data_manager(), registration_id_.service_worker_registration_id(),
+      registration_id_.origin(), registration_id_.developer_id(),
+      base::BindOnce(&HandleGetMetadataCallback, std::move(callback_))));
+  Finished();  // Destroys |this|.
+}
+
+void GetNumRequestsTask::GetRequests(const std::string& key_prefix) {
+  service_worker_context()->GetRegistrationUserDataByKeyPrefix(
+      registration_id_.service_worker_registration_id(), key_prefix,
+      base::BindOnce(&GetNumRequestsTask::DidGetRequests,
+                     weak_factory_.GetWeakPtr()));
+}
+
+void GetNumRequestsTask::DidGetRequests(const std::vector<std::string>& data,
+                                        ServiceWorkerStatusCode status) {
+  DCHECK_EQ(ToDatabaseStatus(status), DatabaseStatus::kOk);
+  std::move(callback_).Run(data.size());
+  Finished();  // Destroys |this|.
+}
+
+}  // namespace background_fetch
+
+}  // namespace content

content/browser/background_fetch/storage/get_num_requests_task.h

+// Copyright 2018 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.
+
+#ifndef CONTENT_BROWSER_BACKGROUND_FETCH_STORAGE_GET_NUM_REQUESTS_TASK_H_
+#define CONTENT_BROWSER_BACKGROUND_FETCH_STORAGE_GET_NUM_REQUESTS_TASK_H_
+
+#include "base/callback_forward.h"
+#include "content/browser/background_fetch/storage/database_task.h"
+#include "content/common/content_export.h"
+#include "content/common/service_worker/service_worker_status_code.h"
+
+namespace content {
+
+namespace background_fetch {
+
+enum class RequestType { kAny, kPending, kActive, kCompleted };
+
+// Gets the number of requests per registration of the given type.
+class CONTENT_EXPORT GetNumRequestsTask : public DatabaseTask {
+ public:
+  using NumRequestsCallback = base::OnceCallback<void(size_t)>;
+
+  GetNumRequestsTask(BackgroundFetchDataManager* data_manager,
+                     const BackgroundFetchRegistrationId& registration_id,
+                     RequestType type,
+                     NumRequestsCallback callback);
+
+  ~GetNumRequestsTask() override;
+
+  // DatabaseTask implementation:
+  void Start() override;
+
+ private:
+  void GetMetadata();
+  void GetRequests(const std::string& key_prefix);
+  void DidGetRequests(const std::vector<std::string>& data,
+                      ServiceWorkerStatusCode status);
+
+  BackgroundFetchRegistrationId registration_id_;
+  RequestType type_;
+  NumRequestsCallback callback_;
+
+  base::WeakPtrFactory<GetNumRequestsTask> weak_factory_;  // Keep as last.
+
+  DISALLOW_COPY_AND_ASSIGN(GetNumRequestsTask);
+};
+
+}  // namespace background_fetch
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_BACKGROUND_FETCH_STORAGE_GET_NUM_REQUESTS_TASK_H_