Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(92)

Side by Side Diff: ui/aura/mus/in_flight_change.cc

Issue 2445163002: Make aura work with mus (Closed)
Patch Set: NON_EXPORTED_BASE_CLASS Created 4 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « ui/aura/mus/in_flight_change.h ('k') | ui/aura/mus/input_method_mus.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2015 The Chromium Authors. All rights reserved. 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 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "services/ui/public/cpp/in_flight_change.h" 5 #include "ui/aura/mus/in_flight_change.h"
6 6
7 #include "services/ui/public/cpp/window_private.h" 7 #include "ui/aura/mus/window_mus.h"
8 #include "services/ui/public/cpp/window_tree_client.h" 8 #include "ui/aura/mus/window_port_mus.h"
9 #include "ui/aura/mus/window_tree_client.h"
10 #include "ui/aura/window.h"
9 11
10 namespace ui { 12 namespace aura {
11 13
12 // InFlightChange ------------------------------------------------------------- 14 // InFlightChange -------------------------------------------------------------
13 15
14 InFlightChange::InFlightChange(Window* window, ChangeType type) 16 InFlightChange::InFlightChange(WindowMus* window, ChangeType type)
15 : window_(window), change_type_(type) {} 17 : window_(window), change_type_(type) {}
16 18
17 InFlightChange::~InFlightChange() {} 19 InFlightChange::~InFlightChange() {}
18 20
19 bool InFlightChange::Matches(const InFlightChange& change) const { 21 bool InFlightChange::Matches(const InFlightChange& change) const {
20 DCHECK(change.window_ == window_ && change.change_type_ == change_type_); 22 DCHECK(change.window_ == window_ && change.change_type_ == change_type_);
21 return true; 23 return true;
22 } 24 }
23 25
24 void InFlightChange::ChangeFailed() {} 26 void InFlightChange::ChangeFailed() {}
25 27
26 // InFlightBoundsChange ------------------------------------------------------- 28 // InFlightBoundsChange -------------------------------------------------------
27 29
28 InFlightBoundsChange::InFlightBoundsChange(Window* window, 30 InFlightBoundsChange::InFlightBoundsChange(WindowMus* window,
29 const gfx::Rect& revert_bounds) 31 const gfx::Rect& revert_bounds)
30 : InFlightChange(window, ChangeType::BOUNDS), 32 : InFlightChange(window, ChangeType::BOUNDS),
31 revert_bounds_(revert_bounds) {} 33 revert_bounds_(revert_bounds) {}
32 34
33 void InFlightBoundsChange::SetRevertValueFrom(const InFlightChange& change) { 35 void InFlightBoundsChange::SetRevertValueFrom(const InFlightChange& change) {
34 revert_bounds_ = 36 revert_bounds_ =
35 static_cast<const InFlightBoundsChange&>(change).revert_bounds_; 37 static_cast<const InFlightBoundsChange&>(change).revert_bounds_;
36 } 38 }
37 39
38 void InFlightBoundsChange::Revert() { 40 void InFlightBoundsChange::Revert() {
39 WindowPrivate(window()).LocalSetBounds(window()->bounds(), revert_bounds_); 41 window()->SetBoundsFromServer(revert_bounds_);
40 } 42 }
41 43
42 // InFlightDragChange ----------------------------------------------------- 44 // InFlightDragChange -----------------------------------------------------
43 45
44 InFlightDragChange::InFlightDragChange(Window* window, ChangeType type) 46 InFlightDragChange::InFlightDragChange(WindowMus* window, ChangeType type)
45 : InFlightChange(window, type) { 47 : InFlightChange(window, type) {
46 DCHECK(type == ChangeType::MOVE_LOOP || type == ChangeType::DRAG_LOOP); 48 DCHECK(type == ChangeType::MOVE_LOOP || type == ChangeType::DRAG_LOOP);
47 } 49 }
48 50
49 void InFlightDragChange::SetRevertValueFrom(const InFlightChange& change) {} 51 void InFlightDragChange::SetRevertValueFrom(const InFlightChange& change) {}
50 52
51 void InFlightDragChange::Revert() {} 53 void InFlightDragChange::Revert() {}
52 54
53 // CrashInFlightChange -------------------------------------------------------- 55 // CrashInFlightChange --------------------------------------------------------
54 56
55 CrashInFlightChange::CrashInFlightChange(Window* window, ChangeType type) 57 CrashInFlightChange::CrashInFlightChange(WindowMus* window, ChangeType type)
56 : InFlightChange(window, type) {} 58 : InFlightChange(window, type) {}
57 59
58 CrashInFlightChange::~CrashInFlightChange() {} 60 CrashInFlightChange::~CrashInFlightChange() {}
59 61
60 void CrashInFlightChange::SetRevertValueFrom(const InFlightChange& change) { 62 void CrashInFlightChange::SetRevertValueFrom(const InFlightChange& change) {
61 CHECK(false); 63 CHECK(false);
62 } 64 }
63 65
64 void CrashInFlightChange::ChangeFailed() { 66 void CrashInFlightChange::ChangeFailed() {
65 DLOG(ERROR) << "changed failed, type=" << static_cast<int>(change_type()); 67 DLOG(ERROR) << "changed failed, type=" << static_cast<int>(change_type());
66 CHECK(false); 68 CHECK(false);
67 } 69 }
68 70
69 void CrashInFlightChange::Revert() { 71 void CrashInFlightChange::Revert() {
70 CHECK(false); 72 CHECK(false);
71 } 73 }
72 74
73 // InFlightWindowChange ------------------------------------------------------- 75 // InFlightWindowChange -------------------------------------------------------
74 76
75 InFlightWindowTreeClientChange::InFlightWindowTreeClientChange( 77 InFlightWindowTreeClientChange::InFlightWindowTreeClientChange(
76 WindowTreeClient* client, 78 WindowTreeClient* client,
77 Window* revert_value, 79 WindowMus* revert_value,
78 ChangeType type) 80 ChangeType type)
79 : InFlightChange(nullptr, type), 81 : InFlightChange(nullptr, type), client_(client), revert_window_(nullptr) {
80 client_(client),
81 revert_window_(nullptr) {
82 SetRevertWindow(revert_value); 82 SetRevertWindow(revert_value);
83 } 83 }
84 84
85 InFlightWindowTreeClientChange::~InFlightWindowTreeClientChange() { 85 InFlightWindowTreeClientChange::~InFlightWindowTreeClientChange() {
86 SetRevertWindow(nullptr); 86 SetRevertWindow(nullptr);
87 } 87 }
88 88
89 void InFlightWindowTreeClientChange::SetRevertValueFrom( 89 void InFlightWindowTreeClientChange::SetRevertValueFrom(
90 const InFlightChange& change) { 90 const InFlightChange& change) {
91 SetRevertWindow(static_cast<const InFlightWindowTreeClientChange&>(change) 91 SetRevertWindow(static_cast<const InFlightWindowTreeClientChange&>(change)
92 .revert_window_); 92 .revert_window_);
93 } 93 }
94 94
95 void InFlightWindowTreeClientChange::SetRevertWindow(Window* window) { 95 void InFlightWindowTreeClientChange::SetRevertWindow(WindowMus* window) {
96 if (revert_window_) 96 if (revert_window_)
97 revert_window_->RemoveObserver(this); 97 revert_window_->GetWindow()->RemoveObserver(this);
98 revert_window_ = window; 98 revert_window_ = window;
99 if (revert_window_) 99 if (revert_window_)
100 revert_window_->AddObserver(this); 100 revert_window_->GetWindow()->AddObserver(this);
101 } 101 }
102 102
103 void InFlightWindowTreeClientChange::OnWindowDestroying(Window* window) { 103 void InFlightWindowTreeClientChange::OnWindowDestroyed(Window* window) {
104 // NOTE: this has to be in OnWindowDestroyed() as FocusClients typically
105 // change focus in OnWindowDestroying().
104 SetRevertWindow(nullptr); 106 SetRevertWindow(nullptr);
105 } 107 }
106 108
107 // InFlightCaptureChange ------------------------------------------------------ 109 // InFlightCaptureChange ------------------------------------------------------
108 110
109 InFlightCaptureChange::InFlightCaptureChange( 111 InFlightCaptureChange::InFlightCaptureChange(WindowTreeClient* client,
110 WindowTreeClient* client, Window* revert_value) 112 WindowMus* revert_value)
111 : InFlightWindowTreeClientChange(client, 113 : InFlightWindowTreeClientChange(client,
112 revert_value, 114 revert_value,
113 ChangeType::CAPTURE) {} 115 ChangeType::CAPTURE) {}
114 116
115 InFlightCaptureChange::~InFlightCaptureChange() {} 117 InFlightCaptureChange::~InFlightCaptureChange() {}
116 118
117 void InFlightCaptureChange::Revert() { 119 void InFlightCaptureChange::Revert() {
118 client()->LocalSetCapture(revert_window()); 120 client()->SetCaptureFromServer(revert_window());
119 } 121 }
120 122
121 // InFlightFocusChange -------------------------------------------------------- 123 // InFlightFocusChange --------------------------------------------------------
122 124
123 InFlightFocusChange::InFlightFocusChange( 125 InFlightFocusChange::InFlightFocusChange(WindowTreeClient* client,
124 WindowTreeClient* client, 126 WindowMus* revert_value)
125 Window* revert_value) 127 : InFlightWindowTreeClientChange(client, revert_value, ChangeType::FOCUS) {}
126 : InFlightWindowTreeClientChange(client,
127 revert_value,
128 ChangeType::FOCUS) {}
129 128
130 InFlightFocusChange::~InFlightFocusChange() {} 129 InFlightFocusChange::~InFlightFocusChange() {}
131 130
132 void InFlightFocusChange::Revert() { 131 void InFlightFocusChange::Revert() {
133 client()->LocalSetFocus(revert_window()); 132 client()->SetFocusFromServer(revert_window());
134 } 133 }
135 134
136 // InFlightPropertyChange ----------------------------------------------------- 135 // InFlightPropertyChange -----------------------------------------------------
137 136
138 InFlightPropertyChange::InFlightPropertyChange( 137 InFlightPropertyChange::InFlightPropertyChange(
139 Window* window, 138 WindowMus* window,
140 const std::string& property_name, 139 const std::string& property_name,
141 const mojo::Array<uint8_t>& revert_value) 140 std::unique_ptr<std::vector<uint8_t>> revert_value)
142 : InFlightChange(window, ChangeType::PROPERTY), 141 : InFlightChange(window, ChangeType::PROPERTY),
143 property_name_(property_name), 142 property_name_(property_name),
144 revert_value_(revert_value.Clone()) {} 143 revert_value_(std::move(revert_value)) {}
145 144
146 InFlightPropertyChange::~InFlightPropertyChange() {} 145 InFlightPropertyChange::~InFlightPropertyChange() {}
147 146
148 bool InFlightPropertyChange::Matches(const InFlightChange& change) const { 147 bool InFlightPropertyChange::Matches(const InFlightChange& change) const {
149 return static_cast<const InFlightPropertyChange&>(change).property_name_ == 148 return static_cast<const InFlightPropertyChange&>(change).property_name_ ==
150 property_name_; 149 property_name_;
151 } 150 }
152 151
153 void InFlightPropertyChange::SetRevertValueFrom(const InFlightChange& change) { 152 void InFlightPropertyChange::SetRevertValueFrom(const InFlightChange& change) {
154 revert_value_ = 153 const InFlightPropertyChange& property_change =
155 static_cast<const InFlightPropertyChange&>(change).revert_value_.Clone(); 154 static_cast<const InFlightPropertyChange&>(change);
155 if (property_change.revert_value_) {
156 revert_value_ =
157 base::MakeUnique<std::vector<uint8_t>>(*property_change.revert_value_);
158 } else {
159 revert_value_.reset();
160 }
156 } 161 }
157 162
158 void InFlightPropertyChange::Revert() { 163 void InFlightPropertyChange::Revert() {
159 WindowPrivate(window()) 164 window()->SetPropertyFromServer(property_name_, revert_value_.get());
160 .LocalSetSharedProperty(property_name_, std::move(revert_value_));
161 } 165 }
162 166
163 // InFlightPredefinedCursorChange --------------------------------------------- 167 // InFlightPredefinedCursorChange ---------------------------------------------
164 168
165 InFlightPredefinedCursorChange::InFlightPredefinedCursorChange( 169 InFlightPredefinedCursorChange::InFlightPredefinedCursorChange(
166 Window* window, 170 WindowMus* window,
167 mojom::Cursor revert_value) 171 ui::mojom::Cursor revert_value)
168 : InFlightChange(window, ChangeType::PREDEFINED_CURSOR), 172 : InFlightChange(window, ChangeType::PREDEFINED_CURSOR),
169 revert_cursor_(revert_value) {} 173 revert_cursor_(revert_value) {}
170 174
171 InFlightPredefinedCursorChange::~InFlightPredefinedCursorChange() {} 175 InFlightPredefinedCursorChange::~InFlightPredefinedCursorChange() {}
172 176
173 void InFlightPredefinedCursorChange::SetRevertValueFrom( 177 void InFlightPredefinedCursorChange::SetRevertValueFrom(
174 const InFlightChange& change) { 178 const InFlightChange& change) {
175 revert_cursor_ = 179 revert_cursor_ =
176 static_cast<const InFlightPredefinedCursorChange&>(change).revert_cursor_; 180 static_cast<const InFlightPredefinedCursorChange&>(change).revert_cursor_;
177 } 181 }
178 182
179 void InFlightPredefinedCursorChange::Revert() { 183 void InFlightPredefinedCursorChange::Revert() {
180 WindowPrivate(window()).LocalSetPredefinedCursor(revert_cursor_); 184 window()->SetPredefinedCursorFromServer(revert_cursor_);
181 } 185 }
182 186
183 // InFlightVisibleChange ------------------------------------------------------- 187 // InFlightVisibleChange -------------------------------------------------------
184 188
185 InFlightVisibleChange::InFlightVisibleChange(Window* window, 189 InFlightVisibleChange::InFlightVisibleChange(WindowMus* window,
186 bool revert_value) 190 bool revert_value)
187 : InFlightChange(window, ChangeType::VISIBLE), 191 : InFlightChange(window, ChangeType::VISIBLE),
188 revert_visible_(revert_value) {} 192 revert_visible_(revert_value) {}
189 193
190 InFlightVisibleChange::~InFlightVisibleChange() {} 194 InFlightVisibleChange::~InFlightVisibleChange() {}
191 195
192 void InFlightVisibleChange::SetRevertValueFrom(const InFlightChange& change) { 196 void InFlightVisibleChange::SetRevertValueFrom(const InFlightChange& change) {
193 revert_visible_ = 197 revert_visible_ =
194 static_cast<const InFlightVisibleChange&>(change).revert_visible_; 198 static_cast<const InFlightVisibleChange&>(change).revert_visible_;
195 } 199 }
196 200
197 void InFlightVisibleChange::Revert() { 201 void InFlightVisibleChange::Revert() {
198 WindowPrivate(window()).LocalSetVisible(revert_visible_); 202 window()->SetVisibleFromServer(revert_visible_);
199 } 203 }
200 204
201 // InFlightOpacityChange ------------------------------------------------------- 205 // InFlightOpacityChange -------------------------------------------------------
202 206
203 InFlightOpacityChange::InFlightOpacityChange(Window* window, float revert_value) 207 InFlightOpacityChange::InFlightOpacityChange(WindowMus* window,
208 float revert_value)
204 : InFlightChange(window, ChangeType::OPACITY), 209 : InFlightChange(window, ChangeType::OPACITY),
205 revert_opacity_(revert_value) {} 210 revert_opacity_(revert_value) {}
206 211
207 InFlightOpacityChange::~InFlightOpacityChange() {} 212 InFlightOpacityChange::~InFlightOpacityChange() {}
208 213
209 void InFlightOpacityChange::SetRevertValueFrom(const InFlightChange& change) { 214 void InFlightOpacityChange::SetRevertValueFrom(const InFlightChange& change) {
210 revert_opacity_ = 215 revert_opacity_ =
211 static_cast<const InFlightOpacityChange&>(change).revert_opacity_; 216 static_cast<const InFlightOpacityChange&>(change).revert_opacity_;
212 } 217 }
213 218
214 void InFlightOpacityChange::Revert() { 219 void InFlightOpacityChange::Revert() {
215 WindowPrivate(window()).LocalSetOpacity(revert_opacity_); 220 window()->SetOpacityFromServer(revert_opacity_);
216 } 221 }
217 222
218 // InFlightSetModalChange ------------------------------------------------------ 223 // InFlightSetModalChange ------------------------------------------------------
219 224
220 InFlightSetModalChange::InFlightSetModalChange(Window* window) 225 InFlightSetModalChange::InFlightSetModalChange(WindowMus* window)
221 : InFlightChange(window, ChangeType::SET_MODAL) {} 226 : InFlightChange(window, ChangeType::SET_MODAL) {}
222 227
223 InFlightSetModalChange::~InFlightSetModalChange() {} 228 InFlightSetModalChange::~InFlightSetModalChange() {}
224 229
225 void InFlightSetModalChange::SetRevertValueFrom(const InFlightChange& change) {} 230 void InFlightSetModalChange::SetRevertValueFrom(const InFlightChange& change) {}
226 231
227 void InFlightSetModalChange::Revert() { 232 void InFlightSetModalChange::Revert() {
228 WindowPrivate(window()).LocalUnsetModal(); 233 // TODO: modality is stored in keys in aura.
234 // WindowPrivate(window()).LocalUnsetModal();
229 } 235 }
230 236
231 } // namespace ui 237 } // namespace aura
OLDNEW
« no previous file with comments | « ui/aura/mus/in_flight_change.h ('k') | ui/aura/mus/input_method_mus.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698