• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2014 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 #include "mojo/services/public/cpp/view_manager/view.h"
6 
7 #include "mojo/public/cpp/application/connect.h"
8 #include "mojo/public/cpp/application/service_provider_impl.h"
9 #include "mojo/public/interfaces/application/shell.mojom.h"
10 #include "mojo/services/public/cpp/view_manager/lib/bitmap_uploader.h"
11 #include "mojo/services/public/cpp/view_manager/lib/view_manager_client_impl.h"
12 #include "mojo/services/public/cpp/view_manager/lib/view_private.h"
13 #include "mojo/services/public/cpp/view_manager/view_observer.h"
14 #include "mojo/services/public/interfaces/gpu/gpu.mojom.h"
15 #include "mojo/services/public/interfaces/surfaces/surfaces_service.mojom.h"
16 #include "ui/gfx/canvas.h"
17 
18 namespace mojo {
19 
20 namespace {
21 
NotifyViewTreeChangeAtReceiver(View * receiver,const ViewObserver::TreeChangeParams & params,bool change_applied)22 void NotifyViewTreeChangeAtReceiver(
23     View* receiver,
24     const ViewObserver::TreeChangeParams& params,
25     bool change_applied) {
26   ViewObserver::TreeChangeParams local_params = params;
27   local_params.receiver = receiver;
28   if (change_applied) {
29     FOR_EACH_OBSERVER(ViewObserver,
30                       *ViewPrivate(receiver).observers(),
31                       OnTreeChanged(local_params));
32   } else {
33     FOR_EACH_OBSERVER(ViewObserver,
34                       *ViewPrivate(receiver).observers(),
35                       OnTreeChanging(local_params));
36   }
37 }
38 
NotifyViewTreeChangeUp(View * start_at,const ViewObserver::TreeChangeParams & params,bool change_applied)39 void NotifyViewTreeChangeUp(
40     View* start_at,
41     const ViewObserver::TreeChangeParams& params,
42     bool change_applied) {
43   for (View* current = start_at; current; current = current->parent())
44     NotifyViewTreeChangeAtReceiver(current, params, change_applied);
45 }
46 
NotifyViewTreeChangeDown(View * start_at,const ViewObserver::TreeChangeParams & params,bool change_applied)47 void NotifyViewTreeChangeDown(
48     View* start_at,
49     const ViewObserver::TreeChangeParams& params,
50     bool change_applied) {
51   NotifyViewTreeChangeAtReceiver(start_at, params, change_applied);
52   View::Children::const_iterator it = start_at->children().begin();
53   for (; it != start_at->children().end(); ++it)
54     NotifyViewTreeChangeDown(*it, params, change_applied);
55 }
56 
NotifyViewTreeChange(const ViewObserver::TreeChangeParams & params,bool change_applied)57 void NotifyViewTreeChange(
58     const ViewObserver::TreeChangeParams& params,
59     bool change_applied) {
60   NotifyViewTreeChangeDown(params.target, params, change_applied);
61   if (params.old_parent)
62     NotifyViewTreeChangeUp(params.old_parent, params, change_applied);
63   if (params.new_parent)
64     NotifyViewTreeChangeUp(params.new_parent, params, change_applied);
65 }
66 
67 class ScopedTreeNotifier {
68  public:
ScopedTreeNotifier(View * target,View * old_parent,View * new_parent)69   ScopedTreeNotifier(View* target, View* old_parent, View* new_parent) {
70     params_.target = target;
71     params_.old_parent = old_parent;
72     params_.new_parent = new_parent;
73     NotifyViewTreeChange(params_, false);
74   }
~ScopedTreeNotifier()75   ~ScopedTreeNotifier() {
76     NotifyViewTreeChange(params_, true);
77   }
78 
79  private:
80   ViewObserver::TreeChangeParams params_;
81 
82   DISALLOW_COPY_AND_ASSIGN(ScopedTreeNotifier);
83 };
84 
RemoveChildImpl(View * child,View::Children * children)85 void RemoveChildImpl(View* child, View::Children* children) {
86   View::Children::iterator it =
87       std::find(children->begin(), children->end(), child);
88   if (it != children->end()) {
89     children->erase(it);
90     ViewPrivate(child).ClearParent();
91   }
92 }
93 
94 class ScopedOrderChangedNotifier {
95  public:
ScopedOrderChangedNotifier(View * view,View * relative_view,OrderDirection direction)96   ScopedOrderChangedNotifier(View* view,
97                              View* relative_view,
98                              OrderDirection direction)
99       : view_(view),
100         relative_view_(relative_view),
101         direction_(direction) {
102     FOR_EACH_OBSERVER(ViewObserver,
103                       *ViewPrivate(view_).observers(),
104                       OnViewReordering(view_, relative_view_, direction_));
105   }
~ScopedOrderChangedNotifier()106   ~ScopedOrderChangedNotifier() {
107     FOR_EACH_OBSERVER(ViewObserver,
108                       *ViewPrivate(view_).observers(),
109                       OnViewReordered(view_, relative_view_, direction_));
110   }
111 
112  private:
113   View* view_;
114   View* relative_view_;
115   OrderDirection direction_;
116 
117   DISALLOW_COPY_AND_ASSIGN(ScopedOrderChangedNotifier);
118 };
119 
120 // Returns true if the order actually changed.
ReorderImpl(View::Children * children,View * view,View * relative,OrderDirection direction)121 bool ReorderImpl(View::Children* children,
122                  View* view,
123                  View* relative,
124                  OrderDirection direction) {
125   DCHECK(relative);
126   DCHECK_NE(view, relative);
127   DCHECK_EQ(view->parent(), relative->parent());
128 
129   const size_t child_i =
130       std::find(children->begin(), children->end(), view) - children->begin();
131   const size_t target_i =
132       std::find(children->begin(), children->end(), relative) -
133       children->begin();
134   if ((direction == ORDER_DIRECTION_ABOVE && child_i == target_i + 1) ||
135       (direction == ORDER_DIRECTION_BELOW && child_i + 1 == target_i)) {
136     return false;
137   }
138 
139   ScopedOrderChangedNotifier notifier(view, relative, direction);
140 
141   const size_t dest_i = direction == ORDER_DIRECTION_ABOVE
142                             ? (child_i < target_i ? target_i : target_i + 1)
143                             : (child_i < target_i ? target_i - 1 : target_i);
144   children->erase(children->begin() + child_i);
145   children->insert(children->begin() + dest_i, view);
146 
147   return true;
148 }
149 
150 class ScopedSetBoundsNotifier {
151  public:
ScopedSetBoundsNotifier(View * view,const gfx::Rect & old_bounds,const gfx::Rect & new_bounds)152   ScopedSetBoundsNotifier(View* view,
153                           const gfx::Rect& old_bounds,
154                           const gfx::Rect& new_bounds)
155       : view_(view),
156         old_bounds_(old_bounds),
157         new_bounds_(new_bounds) {
158     FOR_EACH_OBSERVER(ViewObserver,
159                       *ViewPrivate(view_).observers(),
160                       OnViewBoundsChanging(view_, old_bounds_, new_bounds_));
161   }
~ScopedSetBoundsNotifier()162   ~ScopedSetBoundsNotifier() {
163     FOR_EACH_OBSERVER(ViewObserver,
164                       *ViewPrivate(view_).observers(),
165                       OnViewBoundsChanged(view_, old_bounds_, new_bounds_));
166   }
167 
168  private:
169   View* view_;
170   const gfx::Rect old_bounds_;
171   const gfx::Rect new_bounds_;
172 
173   DISALLOW_COPY_AND_ASSIGN(ScopedSetBoundsNotifier);
174 };
175 
176 // Some operations are only permitted in the connection that created the view.
OwnsView(ViewManager * manager,View * view)177 bool OwnsView(ViewManager* manager, View* view) {
178   return !manager ||
179       static_cast<ViewManagerClientImpl*>(manager)->OwnsView(view->id());
180 }
181 
182 }  // namespace
183 
184 ////////////////////////////////////////////////////////////////////////////////
185 // View, public:
186 
187 // static
Create(ViewManager * view_manager)188 View* View::Create(ViewManager* view_manager) {
189   View* view = new View(view_manager);
190   static_cast<ViewManagerClientImpl*>(view_manager)->AddView(view);
191   return view;
192 }
193 
Destroy()194 void View::Destroy() {
195   if (!OwnsView(manager_, this))
196     return;
197 
198   if (manager_)
199     static_cast<ViewManagerClientImpl*>(manager_)->DestroyView(id_);
200   while (!children_.empty()) {
201     View* child = children_.front();
202     if (!OwnsView(manager_, child)) {
203       ViewPrivate(child).ClearParent();
204       children_.erase(children_.begin());
205     } else {
206       child->Destroy();
207       DCHECK(std::find(children_.begin(), children_.end(), child) ==
208              children_.end());
209     }
210   }
211   LocalDestroy();
212 }
213 
SetBounds(const gfx::Rect & bounds)214 void View::SetBounds(const gfx::Rect& bounds) {
215   if (!OwnsView(manager_, this))
216     return;
217 
218   if (manager_)
219     static_cast<ViewManagerClientImpl*>(manager_)->SetBounds(id_, bounds);
220   LocalSetBounds(bounds_, bounds);
221 }
222 
SetVisible(bool value)223 void View::SetVisible(bool value) {
224   if (manager_)
225     static_cast<ViewManagerClientImpl*>(manager_)->SetVisible(id_, value);
226 }
227 
AddObserver(ViewObserver * observer)228 void View::AddObserver(ViewObserver* observer) {
229   observers_.AddObserver(observer);
230 }
231 
RemoveObserver(ViewObserver * observer)232 void View::RemoveObserver(ViewObserver* observer) {
233   observers_.RemoveObserver(observer);
234 }
235 
AddChild(View * child)236 void View::AddChild(View* child) {
237   // TODO(beng): not necessarily valid to all connections, but possibly to the
238   //             embeddee in an embedder-embeddee relationship.
239   if (manager_)
240     CHECK_EQ(ViewPrivate(child).view_manager(), manager_);
241   LocalAddChild(child);
242   if (manager_)
243     static_cast<ViewManagerClientImpl*>(manager_)->AddChild(child->id(), id_);
244 }
245 
RemoveChild(View * child)246 void View::RemoveChild(View* child) {
247   // TODO(beng): not necessarily valid to all connections, but possibly to the
248   //             embeddee in an embedder-embeddee relationship.
249   if (manager_)
250     CHECK_EQ(ViewPrivate(child).view_manager(), manager_);
251   LocalRemoveChild(child);
252   if (manager_) {
253     static_cast<ViewManagerClientImpl*>(manager_)->RemoveChild(child->id(),
254                                                                id_);
255   }
256 }
257 
MoveToFront()258 void View::MoveToFront() {
259   Reorder(parent_->children_.back(), ORDER_DIRECTION_ABOVE);
260 }
261 
MoveToBack()262 void View::MoveToBack() {
263   Reorder(parent_->children_.front(), ORDER_DIRECTION_BELOW);
264 }
265 
Reorder(View * relative,OrderDirection direction)266 void View::Reorder(View* relative, OrderDirection direction) {
267   if (!LocalReorder(relative, direction))
268     return;
269   if (manager_) {
270     static_cast<ViewManagerClientImpl*>(manager_)->Reorder(id_,
271                                                             relative->id(),
272                                                             direction);
273   }
274 }
275 
Contains(View * child) const276 bool View::Contains(View* child) const {
277   if (manager_)
278     CHECK_EQ(ViewPrivate(child).view_manager(), manager_);
279   for (View* p = child->parent(); p; p = p->parent()) {
280     if (p == this)
281       return true;
282   }
283   return false;
284 }
285 
GetChildById(Id id)286 View* View::GetChildById(Id id) {
287   if (id == id_)
288     return this;
289   // TODO(beng): this could be improved depending on how we decide to own views.
290   Children::const_iterator it = children_.begin();
291   for (; it != children_.end(); ++it) {
292     View* view = (*it)->GetChildById(id);
293     if (view)
294       return view;
295   }
296   return NULL;
297 }
298 
SetSurfaceId(SurfaceIdPtr id)299 void View::SetSurfaceId(SurfaceIdPtr id) {
300   if (manager_) {
301     static_cast<ViewManagerClientImpl*>(manager_)->SetSurfaceId(id_, id.Pass());
302   }
303 }
304 
SetContents(const SkBitmap & contents)305 void View::SetContents(const SkBitmap& contents) {
306   if (manager_) {
307     if (!bitmap_uploader_)
308       CreateBitmapUploader();
309     bitmap_uploader_->SetSize(bounds_.size());
310     bitmap_uploader_->SetBitmap(contents);
311   }
312 }
313 
SetColor(SkColor color)314 void View::SetColor(SkColor color) {
315   if (manager_) {
316     if (!bitmap_uploader_)
317       CreateBitmapUploader();
318     bitmap_uploader_->SetSize(bounds_.size());
319     bitmap_uploader_->SetColor(color);
320   }
321 }
322 
SetFocus()323 void View::SetFocus() {
324   if (manager_)
325     static_cast<ViewManagerClientImpl*>(manager_)->SetFocus(id_);
326 }
327 
Embed(const String & url)328 void View::Embed(const String& url) {
329   static_cast<ViewManagerClientImpl*>(manager_)->Embed(url, id_);
330 }
331 
332 scoped_ptr<ServiceProvider>
Embed(const String & url,scoped_ptr<ServiceProviderImpl> exported_services)333     View::Embed(const String& url,
334                 scoped_ptr<ServiceProviderImpl> exported_services) {
335   scoped_ptr<ServiceProvider> imported_services;
336   // BindToProxy() takes ownership of |exported_services|.
337   ServiceProviderImpl* registry = exported_services.release();
338   ServiceProviderPtr sp;
339   if (registry) {
340     BindToProxy(registry, &sp);
341     imported_services.reset(registry->CreateRemoteServiceProvider());
342   }
343   static_cast<ViewManagerClientImpl*>(manager_)->Embed(url, id_, sp.Pass());
344   return imported_services.Pass();
345 }
346 
347 ////////////////////////////////////////////////////////////////////////////////
348 // View, protected:
349 
View()350 View::View()
351     : manager_(NULL),
352       id_(static_cast<Id>(-1)),
353       parent_(NULL) {}
354 
~View()355 View::~View() {
356   FOR_EACH_OBSERVER(ViewObserver, observers_, OnViewDestroying(this));
357   if (parent_)
358     parent_->LocalRemoveChild(this);
359   // TODO(beng): It'd be better to do this via a destruction observer in the
360   //             ViewManagerClientImpl.
361   if (manager_)
362     static_cast<ViewManagerClientImpl*>(manager_)->RemoveView(id_);
363   FOR_EACH_OBSERVER(ViewObserver, observers_, OnViewDestroyed(this));
364 }
365 
366 ////////////////////////////////////////////////////////////////////////////////
367 // View, private:
368 
View(ViewManager * manager)369 View::View(ViewManager* manager)
370     : manager_(manager),
371       id_(static_cast<ViewManagerClientImpl*>(manager_)->CreateView()),
372       parent_(NULL) {}
373 
LocalDestroy()374 void View::LocalDestroy() {
375   delete this;
376 }
377 
LocalAddChild(View * child)378 void View::LocalAddChild(View* child) {
379   ScopedTreeNotifier notifier(child, child->parent(), this);
380   if (child->parent())
381     RemoveChildImpl(child, &child->parent_->children_);
382   children_.push_back(child);
383   child->parent_ = this;
384 }
385 
LocalRemoveChild(View * child)386 void View::LocalRemoveChild(View* child) {
387   DCHECK_EQ(this, child->parent());
388   ScopedTreeNotifier notifier(child, this, NULL);
389   RemoveChildImpl(child, &children_);
390 }
391 
LocalReorder(View * relative,OrderDirection direction)392 bool View::LocalReorder(View* relative, OrderDirection direction) {
393   return ReorderImpl(&parent_->children_, this, relative, direction);
394 }
395 
LocalSetBounds(const gfx::Rect & old_bounds,const gfx::Rect & new_bounds)396 void View::LocalSetBounds(const gfx::Rect& old_bounds,
397                           const gfx::Rect& new_bounds) {
398   DCHECK(old_bounds == bounds_);
399   ScopedSetBoundsNotifier notifier(this, old_bounds, new_bounds);
400   bounds_ = new_bounds;
401 }
402 
CreateBitmapUploader()403 void View::CreateBitmapUploader() {
404   ViewManagerClientImpl* vmci = static_cast<ViewManagerClientImpl*>(manager_);
405   SurfacesServicePtr surfaces_service;
406   InterfacePtr<ServiceProvider> surfaces_service_provider;
407   vmci->shell()->ConnectToApplication("mojo:mojo_surfaces_service",
408                                       Get(&surfaces_service_provider));
409   ConnectToService(surfaces_service_provider.get(), &surfaces_service);
410   GpuPtr gpu_service;
411   InterfacePtr<ServiceProvider> gpu_service_provider;
412   vmci->shell()->ConnectToApplication("mojo:mojo_native_viewport_service",
413                                       Get(&gpu_service_provider));
414   ConnectToService(gpu_service_provider.get(), &gpu_service);
415   bitmap_uploader_.reset(new BitmapUploader(
416       vmci, id_, surfaces_service.Pass(), gpu_service.Pass()));
417 }
418 
419 }  // namespace mojo
420