Move ScopedWebCallbacks out of the Blink exposed API

WebCallbacks is now solely used within by blink::ImageCaptureFrameGrabber.
This CL moves its definition out of the Blink exposed API into
image_capture_frame_grabber.h

This is a follow up of the following CLs:

- crrev.com/c/1546151
  (Remove the use of blink::ScopedWebCallbacks in MediaRecorderHandler::EncodingInfo)
- crrev.com/c/1546155
  (Remove the use of blink::ScopedWebCallbacks in TransmissionEncodingInfoHandler::EncodingInfo)
- crrev.com/c/1576468
  (Onion soup content/renderer/image_capture/)

In a final step, its complete removal will be pursued.

BUG=919392,945851
R=haraken@chromium.org

Change-Id: I35ee4c0cfb6a317f3e661859d3fed2447cc968ae
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1610117
Commit-Queue: Antonio Gomes <tonikitoo@igalia.com>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Auto-Submit: Antonio Gomes <tonikitoo@igalia.com>
Cr-Commit-Position: refs/heads/master@{#659162}

third_party/blink/public/BUILD.gn

@@ -184,7 +184,6 @@ source_set("blink_headers") {
     "platform/scheduler/web_resource_loading_task_runner_handle.h",
     "platform/scheduler/web_scoped_virtual_time_pauser.h",
     "platform/scheduler/web_thread_scheduler.h",
-    "platform/scoped_web_callbacks.h",
     "platform/shape_properties.h",
     "platform/task_type.h",
     "platform/url_conversion.h",

third_party/blink/public/platform/scoped_web_callbacks.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 THIRD_PARTY_BLINK_PUBLIC_PLATFORM_SCOPED_WEB_CALLBACKS_H_
-#define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_SCOPED_WEB_CALLBACKS_H_
-
-#include <memory>
-#include <utility>
-
-#include "base/callback.h"
-#include "third_party/blink/public/platform/web_callbacks.h"
-
-namespace blink {
-
-// A ScopedWebCallbacks is a move-only scoper which helps manage the lifetime of
-// a blink::WebCallbacks object. This is particularly useful when you're
-// simultaneously dealing with the following two conditions:
-//
-//   1. Your WebCallbacks implementation requires either onSuccess or onError to
-//      be called before it's destroyed. This is the case with
-//      CallbackPromiseAdapter for example, because its underlying
-//      ScriptPromiseResolver must be resolved or rejected before destruction.
-//
-//   2. You are passing ownership of the WebCallbacks to code which may
-//      silenty drop it. A common way for this to happen is to bind the
-//      WebCallbacks as an argument to a base::Callback which gets destroyed
-//      before it can run.
-//
-// While it's possible to individually track the lifetime of pending
-// WebCallbacks, this becomes cumbersome when dealing with many different
-// callbacks types. ScopedWebCallbacks provides a generic and relatively
-// lightweight solution to this problem.
-//
-// Example usage:
-//
-//   using FooCallbacks = blink::WebCallbacks<const Foo&, const FooError&>;
-//
-//   void RespondWithSuccess(ScopedWebCallbacks<FooCallbacks> callbacks) {
-//     callbacks.PassCallbacks()->onSuccess(Foo("everything is great"));
-//   }
-//
-//   void OnCallbacksDropped(std::unique_ptr<FooCallbacks> callbacks) {
-//     // Ownership of the FooCallbacks is passed to this function if
-//     // ScopedWebCallbacks::PassCallbacks isn't called before the
-//     // ScopedWebCallbacks is destroyed.
-//     callbacks->onError(FooError("everything is terrible"));
-//   }
-//
-//   // Blink client implementation
-//   void FooClientImpl::doMagic(std::unique_ptr<FooCallbacks> callbacks) {
-//     auto scoped_callbacks = make_scoped_web_callbacks(
-//         std::move(callbacks), base::BindOnce(&OnCallbacksDropped));
-//
-//     // Call to some lower-level service which may never run the callback we
-//     // give it.
-//     foo_service_->DoMagic(base::BindOnce(&RespondWithSuccess,
-//                                          std::move(scoped_callbacks)));
-//   }
-//
-// If the bound RespondWithSuccess callback actually runs, PassCallbacks() will
-// reliquish ownership of the WebCallbacks object to a temporary scoped_ptr
-// which will be destroyed immediately after onSuccess is called.
-//
-// If the bound RespondWithSuccess callback is instead destroyed first,
-// the ScopedWebCallbacks destructor will invoke OnCallbacksDropped, executing
-// our desired default behavior before deleting the WebCallbacks.
-template <typename CallbacksType>
-class ScopedWebCallbacks {
- public:
-  using DestructionCallback =
-      base::OnceCallback<void(std::unique_ptr<CallbacksType> callbacks)>;
-
-  ScopedWebCallbacks(std::unique_ptr<CallbacksType> callbacks,
-                     DestructionCallback destruction_callback)
-      : callbacks_(std::move(callbacks)),
-        destruction_callback_(std::move(destruction_callback)) {}
-
-  ~ScopedWebCallbacks() {
-    if (destruction_callback_)
-      std::move(destruction_callback_).Run(std::move(callbacks_));
-  }
-
-  ScopedWebCallbacks(ScopedWebCallbacks&& other) = default;
-  ScopedWebCallbacks(const ScopedWebCallbacks& other) = delete;
-
-  ScopedWebCallbacks& operator=(ScopedWebCallbacks&& other) = default;
-  ScopedWebCallbacks& operator=(const ScopedWebCallbacks& other) = delete;
-
-  std::unique_ptr<CallbacksType> PassCallbacks() {
-    destruction_callback_ = DestructionCallback();
-    return std::move(callbacks_);
-  }
-
- private:
-  std::unique_ptr<CallbacksType> callbacks_;
-  DestructionCallback destruction_callback_;
-};
-
-template <typename CallbacksType>
-ScopedWebCallbacks<CallbacksType> MakeScopedWebCallbacks(
-    std::unique_ptr<CallbacksType> callbacks,
-    typename ScopedWebCallbacks<CallbacksType>::DestructionCallback
-        destruction_callback) {
-  return ScopedWebCallbacks<CallbacksType>(std::move(callbacks),
-                                           std::move(destruction_callback));
-}
-
-}  // namespace blink
-
-#endif  // THIRD_PARTY_BLINK_PUBLIC_PLATFORM_SCOPED_WEB_CALLBACKS_H_

third_party/blink/renderer/modules/imagecapture/image_capture_frame_grabber.h

@@ -7,11 +7,12 @@
 
 #include <memory>
 
+#include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_checker.h"
-#include "third_party/blink/public/platform/scoped_web_callbacks.h"
+#include "third_party/blink/public/platform/web_callbacks.h"
 #include "third_party/blink/public/web/modules/mediastream/media_stream_video_sink.h"
 #include "third_party/blink/renderer/bindings/core/v8/callback_promise_adapter.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
@@ -23,6 +24,99 @@ namespace blink {
 class ImageBitmap;
 class WebMediaStreamTrack;
 
+// A ScopedWebCallbacks is a move-only scoper which helps manage the lifetime of
+// a blink::WebCallbacks object. This is particularly useful when you're
+// simultaneously dealing with the following two conditions:
+//
+//   1. Your WebCallbacks implementation requires either onSuccess or onError to
+//      be called before it's destroyed. This is the case with
+//      CallbackPromiseAdapter for example, because its underlying
+//      ScriptPromiseResolver must be resolved or rejected before destruction.
+//
+//   2. You are passing ownership of the WebCallbacks to code which may
+//      silenty drop it. A common way for this to happen is to bind the
+//      WebCallbacks as an argument to a base::Callback which gets destroyed
+//      before it can run.
+//
+// While it's possible to individually track the lifetime of pending
+// WebCallbacks, this becomes cumbersome when dealing with many different
+// callbacks types. ScopedWebCallbacks provides a generic and relatively
+// lightweight solution to this problem.
+//
+// Example usage:
+//
+//   using FooCallbacks = blink::WebCallbacks<const Foo&, const FooError&>;
+//
+//   void RespondWithSuccess(ScopedWebCallbacks<FooCallbacks> callbacks) {
+//     callbacks.PassCallbacks()->onSuccess(Foo("everything is great"));
+//   }
+//
+//   void OnCallbacksDropped(std::unique_ptr<FooCallbacks> callbacks) {
+//     // Ownership of the FooCallbacks is passed to this function if
+//     // ScopedWebCallbacks::PassCallbacks isn't called before the
+//     // ScopedWebCallbacks is destroyed.
+//     callbacks->onError(FooError("everything is terrible"));
+//   }
+//
+//   // Blink client implementation
+//   void FooClientImpl::doMagic(std::unique_ptr<FooCallbacks> callbacks) {
+//     auto scoped_callbacks = make_scoped_web_callbacks(
+//         std::move(callbacks), base::BindOnce(&OnCallbacksDropped));
+//
+//     // Call to some lower-level service which may never run the callback we
+//     // give it.
+//     foo_service_->DoMagic(base::BindOnce(&RespondWithSuccess,
+//                                          std::move(scoped_callbacks)));
+//   }
+//
+// If the bound RespondWithSuccess callback actually runs, PassCallbacks() will
+// reliquish ownership of the WebCallbacks object to a temporary scoped_ptr
+// which will be destroyed immediately after onSuccess is called.
+//
+// If the bound RespondWithSuccess callback is instead destroyed first,
+// the ScopedWebCallbacks destructor will invoke OnCallbacksDropped, executing
+// our desired default behavior before deleting the WebCallbacks.
+template <typename CallbacksType>
+class ScopedWebCallbacks {
+ public:
+  using DestructionCallback =
+      base::OnceCallback<void(std::unique_ptr<CallbacksType> callbacks)>;
+
+  ScopedWebCallbacks(std::unique_ptr<CallbacksType> callbacks,
+                     DestructionCallback destruction_callback)
+      : callbacks_(std::move(callbacks)),
+        destruction_callback_(std::move(destruction_callback)) {}
+
+  ~ScopedWebCallbacks() {
+    if (destruction_callback_)
+      std::move(destruction_callback_).Run(std::move(callbacks_));
+  }
+
+  ScopedWebCallbacks(ScopedWebCallbacks&& other) = default;
+  ScopedWebCallbacks(const ScopedWebCallbacks& other) = delete;
+
+  ScopedWebCallbacks& operator=(ScopedWebCallbacks&& other) = default;
+  ScopedWebCallbacks& operator=(const ScopedWebCallbacks& other) = delete;
+
+  std::unique_ptr<CallbacksType> PassCallbacks() {
+    destruction_callback_ = DestructionCallback();
+    return std::move(callbacks_);
+  }
+
+ private:
+  std::unique_ptr<CallbacksType> callbacks_;
+  DestructionCallback destruction_callback_;
+};
+
+template <typename CallbacksType>
+ScopedWebCallbacks<CallbacksType> MakeScopedWebCallbacks(
+    std::unique_ptr<CallbacksType> callbacks,
+    typename ScopedWebCallbacks<CallbacksType>::DestructionCallback
+        destruction_callback) {
+  return ScopedWebCallbacks<CallbacksType>(std::move(callbacks),
+                                           std::move(destruction_callback));
+}
+
 using ImageCaptureGrabFrameCallbacks =
     CallbackPromiseAdapter<ImageBitmap, void>;