content/child/scoped_web_callbacks.h

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_CHILD_SCOPED_WEB_CALLBACKS_H_
   6 #define CONTENT_CHILD_SCOPED_WEB_CALLBACKS_H_
   7
   8 #include "base/callback.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/move.h"
  11 #include "third_party/WebKit/public/platform/WebCallbacks.h"
  12
  13 // A ScopedWebCallbacks is a move-only scoper which helps manage the lifetime of
  14 // a blink::WebCallbacks object. This is particularly useful when you're
  15 // simultaneously dealing with the following two conditions:
  16 //
  17 //   1. Your WebCallbacks implementation requires either onSuccess or onError to
  18 //      be called before it's destroyed. This is the case with
  19 //      CallbackPromiseAdapter for example, because its underlying
  20 //      ScriptPromiseResolver must be resolved or rejected before destruction.
  21 //
  22 //   2. You are passing ownership of the WebCallbacks to code which may
  23 //      silenty drop it. A common way for this to happen is to bind the
  24 //      WebCallbacks as an argument to a base::Callback which gets destroyed
  25 //      before it can run.
  26 //
  27 // While it's possible to individually track the lifetime of pending
  28 // WebCallbacks, this becomes cumbersome when dealing with many different
  29 // callbacks types. ScopedWebCallbacks provides a generic and relatively
  30 // lightweight solution to this problem.
  31 //
  32 // Example usage:
  33 //
  34 //   using FooCallbacks = blink::WebCallbacks<const Foo&, const FooError&>;
  35 //
  36 //   void RespondWithSuccess(ScopedWebCallbacks<FooCallbacks> callbacks) {
  37 //     callbacks.PassCallbacks()->onSuccess(Foo("everything is great"));
  38 //   }
  39 //
  40 //   void OnCallbacksDropped(scoped_ptr<FooCallbacks> callbacks) {
  41 //     // Ownership of the FooCallbacks is passed to this function if
  42 //     // ScopedWebCallbacks::PassCallbacks isn't called before the
  43 //     // ScopedWebCallbacks is destroyed.
  44 //     callbacks->onError(FooError("everything is terrible"));
  45 //   }
  46 //
  47 //   // Blink client implementation
  48 //   void FooClientImpl::doMagic(FooCallbacks* callbacks) {
  49 //     auto scoped_callbacks = make_scoped_web_callbacks(
  50 //         callbacks, base::Bind(&OnCallbacksDropped));
  51 //
  52 //     // Call to some lower-level service which may never run the callback we
  53 //     // give it.
  54 //     foo_service_->DoMagic(base::Bind(&RespondWithSuccess,
  55 //                                      base::Passed(&scoped_callbacks)));
  56 //   }
  57 //
  58 // If the bound RespondWithSuccess callback actually runs, PassCallbacks() will
  59 // reliquish ownership of the WebCallbacks object to a temporary scoped_ptr
  60 // which will be destroyed immediately after onSuccess is called.
  61 //
  62 // If the bound RespondWithSuccess callback is instead destroyed first,
  63 // the ScopedWebCallbacks destructor will invoke OnCallbacksDropped, executing
  64 // our desired default behavior before deleting the WebCallbacks.
  65 template <typename CallbacksType>
  66 class ScopedWebCallbacks {
  67   MOVE_ONLY_TYPE_FOR_CPP_03(ScopedWebCallbacks, RValue);
  68
  69  public:
  70   using DestructionCallback =
  71       base::Callback<void(scoped_ptr<CallbacksType> callbacks)>;
  72
  73   ScopedWebCallbacks(scoped_ptr<CallbacksType> callbacks,
  74                      const DestructionCallback& destruction_callback)
  75       : callbacks_(callbacks.Pass()),
  76         destruction_callback_(destruction_callback) {}
  77
  78   ~ScopedWebCallbacks() {
  79     if (callbacks_)
  80       destruction_callback_.Run(callbacks_.Pass());
  81   }
  82
  83   ScopedWebCallbacks(RValue other) { *this = other; }
  84
  85   ScopedWebCallbacks& operator=(RValue other) {
  86     callbacks_ = other.object->callbacks_.Pass();
  87     destruction_callback_ = other.object->destruction_callback_;
  88     return *this;
  89   }
  90
  91   scoped_ptr<CallbacksType> PassCallbacks() { return callbacks_.Pass(); }
  92
  93  private:
  94   scoped_ptr<CallbacksType> callbacks_;
  95   DestructionCallback destruction_callback_;
  96 };
  97
  98 template <typename CallbacksType>
  99 ScopedWebCallbacks<CallbacksType> make_scoped_web_callbacks(
 100     CallbacksType* callbacks,
 101     const typename ScopedWebCallbacks<CallbacksType>::DestructionCallback&
 102         destruction_callback) {
 103   return ScopedWebCallbacks<CallbacksType>(make_scoped_ptr(callbacks),
 104                                            destruction_callback);
 105 }
 106
 107 #endif  // CONTENT_CHILD_SCOPED_WEB_CALLBACKS_H_