Hook up the other Background Fetch Mojo methods with the system

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_job_controller.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 {
 
@@ skipping 65 matching lines @@
     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.
+  BackgroundFetchJobController* controller =
+      background_fetch_context_->GetActiveFetch(BackgroundFetchRegistrationId(
+          service_worker_registration_id, origin, tag));
 
-  callback.Run(blink::mojom::BackgroundFetchError::NONE);
+  if (controller)
+    controller->UpdateUI(title);
+
+  callback.Run(controller ? blink::mojom::BackgroundFetchError::NONE
+                          : blink::mojom::BackgroundFetchError::INVALID_TAG);
 }
 
 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.
+  BackgroundFetchJobController* controller =
+      background_fetch_context_->GetActiveFetch(BackgroundFetchRegistrationId(
+          service_worker_registration_id, origin, tag));
 
-  callback.Run(blink::mojom::BackgroundFetchError::NONE);
+  if (controller)
+    controller->Abort();
+
+  callback.Run(controller ? blink::mojom::BackgroundFetchError::NONE
+                          : blink::mojom::BackgroundFetchError::INVALID_TAG);
 }
 
 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.
+  BackgroundFetchJobController* controller =
+      background_fetch_context_->GetActiveFetch(BackgroundFetchRegistrationId(
+          service_worker_registration_id, origin, tag));
 
-  callback.Run(blink::mojom::BackgroundFetchError::NONE,
-               base::nullopt /* registration */);
+  if (!controller) {
+    callback.Run(blink::mojom::BackgroundFetchError::INVALID_TAG,
+                 base::nullopt /* registration */);
+    return;
+  }
+
+  // Compile the BackgroundFetchRegistration object that will be given to the
+  // developer, representing the data associated with the |controller|.
+  BackgroundFetchRegistration registration;
+  registration.tag = controller->registration_id().tag();
+  registration.icons = controller->options().icons;
+  registration.title = controller->options().title;
+  registration.total_download_size = controller->options().total_download_size;
+
+  callback.Run(blink::mojom::BackgroundFetchError::NONE, 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>());
+  callback.Run(
+      blink::mojom::BackgroundFetchError::NONE,
+      background_fetch_context_->GetActiveTagsForServiceWorkerRegistration(
+          service_worker_registration_id, origin));
 }
 
 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;
@@ skipping 14 matching lines @@
   if (title.empty() || title.size() > kMaxTitleLength) {
     bad_message::ReceivedBadMessage(render_process_id_,
                                     bad_message::BFSI_INVALID_TITLE);
     return false;
   }
 
   return true;
 }
 
 }  // namespace content