Hook up BackgroundFetchServiceImpl::Fetch() to start a fetch

content/browser/background_fetch/background_fetch_service_impl.cc

 // Copyright 2017 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/background_fetch_service_impl.h"
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/optional.h"
 #include "content/browser/background_fetch/background_fetch_context.h"
+#include "content/browser/background_fetch/background_fetch_registration_id.h"
+#include "content/browser/bad_message.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/common/background_fetch/background_fetch_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "url/origin.h"
 
 namespace content {
 
+namespace {
+
+// Maximum length of a developer-provided tag for a Background Fetch.
+constexpr size_t kMaxTagLength = 1024 * 1024;
+
+// Maximum length of a developer-provided title for a Background Fetch.
+constexpr size_t kMaxTitleLength = 1024 * 1024;
+
+}  // namespace
+
 // static
 void BackgroundFetchServiceImpl::Create(
+    int render_process_id,
     scoped_refptr<BackgroundFetchContext> background_fetch_context,
-    scoped_refptr<ServiceWorkerContextWrapper> service_worker_context,
     blink::mojom::BackgroundFetchServiceRequest request) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  mojo::MakeStrongBinding(base::MakeUnique<BackgroundFetchServiceImpl>(
-                              std::move(background_fetch_context),
-                              std::move(service_worker_context)),
-                          std::move(request));
+  mojo::MakeStrongBinding(
+      base::MakeUnique<BackgroundFetchServiceImpl>(
+          render_process_id, std::move(background_fetch_context)),
+      std::move(request));
 }
 
 BackgroundFetchServiceImpl::BackgroundFetchServiceImpl(
-    scoped_refptr<BackgroundFetchContext> background_fetch_context,
-    scoped_refptr<ServiceWorkerContextWrapper> service_worker_context)
-    : background_fetch_context_(std::move(background_fetch_context)),
-      service_worker_context_(std::move(service_worker_context)) {
+    int render_process_id,
+    scoped_refptr<BackgroundFetchContext> background_fetch_context)
+    : render_process_id_(render_process_id),
+      background_fetch_context_(std::move(background_fetch_context)) {
   DCHECK(background_fetch_context_);
-  DCHECK(service_worker_context_);
 }
 
 BackgroundFetchServiceImpl::~BackgroundFetchServiceImpl() = default;
 
 void BackgroundFetchServiceImpl::Fetch(int64_t service_worker_registration_id,
                                        const url::Origin& origin,
                                        const std::string& tag,
                                        const BackgroundFetchOptions& options,
                                        const FetchCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (!ValidateTag(tag)) {
+    callback.Run(blink::mojom::BackgroundFetchError::INVALID_ARGUMENT,
+                 base::nullopt /* registration */);
+    return;
+  }
 
-  // TODO(peter): Create a new job with the BackgroundFetchContext for the
-  // given tag, requests and options. For now we return a registration that's
-  // based on the given |options|, to make sure round-trip is covered.
+  BackgroundFetchRegistrationId registration_id(service_worker_registration_id,
+                                                origin, tag);
 
-  BackgroundFetchRegistration registration;
-  registration.tag = tag;
-  registration.icons = options.icons;
-  registration.title = options.title;
-  registration.total_download_size = options.total_download_size;
+  // TODO(peter): Remove once https://codereview.chromium.org/2762303002/ lands.
+  std::vector<ServiceWorkerFetchRequest> requests;
+  requests.emplace_back(GURL("https://example.com/image.png"), "POST",
+                        ServiceWorkerHeaderMap(), Referrer(),
+                        false /* is_reload */);
 
-  callback.Run(blink::mojom::BackgroundFetchError::NONE, registration);
+  if (!ValidateRequests(requests)) {
+    callback.Run(blink::mojom::BackgroundFetchError::INVALID_ARGUMENT,
+                 base::nullopt /* registration */);
+    return;
+  }
+
+  background_fetch_context_->StartFetch(registration_id, requests, options,
+                                        callback);
 }
 
 void BackgroundFetchServiceImpl::UpdateUI(
     int64_t service_worker_registration_id,
     const url::Origin& origin,
     const std::string& tag,
     const std::string& title,
     const UpdateUICallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (!ValidateTag(tag) || !ValidateTitle(title)) {
+    callback.Run(blink::mojom::BackgroundFetchError::INVALID_ARGUMENT);
+    return;
+  }
 
   // TODO(peter): Get the BackgroundFetchJobController for the
   // {service_worker_registration_id, tag} pair and call UpdateUI() on it.
 
   callback.Run(blink::mojom::BackgroundFetchError::NONE);
 }
 
 void BackgroundFetchServiceImpl::Abort(int64_t service_worker_registration_id,
                                        const url::Origin& origin,
                                        const std::string& tag,
                                        const AbortCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (!ValidateTag(tag)) {
+    callback.Run(blink::mojom::BackgroundFetchError::INVALID_ARGUMENT);
+    return;
+  }
 
   // TODO(peter): Get the BackgroundFetchJobController for the
   // {service_worker_registration_id, tag} pair and call Abort() on it.
 
   callback.Run(blink::mojom::BackgroundFetchError::NONE);
 }
 
 void BackgroundFetchServiceImpl::GetRegistration(
     int64_t service_worker_registration_id,
     const url::Origin& origin,
     const std::string& tag,
     const GetRegistrationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (!ValidateTag(tag)) {
+    callback.Run(blink::mojom::BackgroundFetchError::INVALID_ARGUMENT,
+                 base::nullopt /* registration */);
+    return;
+  }
 
   // TODO(peter): Get the registration for {service_worker_registration_id, tag}
   // and construct a BackgroundFetchRegistrationPtr for it.
 
   callback.Run(blink::mojom::BackgroundFetchError::NONE,
                base::nullopt /* registration */);
 }
 
 void BackgroundFetchServiceImpl::GetTags(int64_t service_worker_registration_id,
                                          const url::Origin& origin,
                                          const GetTagsCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // TODO(peter): Get the list of active Background Fetches associated with
   // service_worker_registration_id and share their tags.
 
   callback.Run(blink::mojom::BackgroundFetchError::NONE,
                std::vector<std::string>());
 }
 
+bool BackgroundFetchServiceImpl::ValidateTag(const std::string& tag) {
+  if (tag.empty() || tag.size() > kMaxTagLength) {
+    bad_message::ReceivedBadMessage(render_process_id_,
+                                    bad_message::BFSI_INVALID_TAG);
+    return false;
+  }
+
+  return true;
+}
+
+bool BackgroundFetchServiceImpl::ValidateRequests(
+    const std::vector<ServiceWorkerFetchRequest>& requests) {
+  if (requests.empty()) {
+    bad_message::ReceivedBadMessage(render_process_id_,
+                                    bad_message::BFSI_INVALID_REQUESTS);
+    return false;
+  }
+
+  return true;
+}
+
+bool BackgroundFetchServiceImpl::ValidateTitle(const std::string& title) {
+  if (title.empty() || title.size() > kMaxTitleLength) {
+    bad_message::ReceivedBadMessage(render_process_id_,
+                                    bad_message::BFSI_INVALID_TITLE);
+    return false;
+  }
+
+  return true;
+}
+
 }  // namespace content