OLD | NEW |
---|---|
(Empty) | |
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 // simultaenously dealing with the following two conditions: | |
jam
2015/08/18 05:14:32
nit: spelling
Ken Rockot(use gerrit already)
2015/08/18 22:29:11
Done.
| |
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_ | |
OLD | NEW |