components/view_manager/view_manager_service_impl.cc

   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 "components/view_manager/view_manager_service_impl.h"
   6
   7 #include "base/bind.h"
   8 #include "base/stl_util.h"
   9 #include "components/view_manager/connection_manager.h"
  10 #include "components/view_manager/default_access_policy.h"
  11 #include "components/view_manager/display_manager.h"
  12 #include "components/view_manager/server_view.h"
  13 #include "components/view_manager/window_manager_access_policy.h"
  14 #include "mojo/converters/geometry/geometry_type_converters.h"
  15 #include "mojo/converters/input_events/input_events_type_converters.h"
  16 #include "mojo/converters/surfaces/surfaces_type_converters.h"
  17
  18 using mojo::Array;
  19 using mojo::Callback;
  20 using mojo::Id;
  21 using mojo::InterfaceRequest;
  22 using mojo::OrderDirection;
  23 using mojo::Rect;
  24 using mojo::ServiceProvider;
  25 using mojo::ServiceProviderPtr;
  26 using mojo::String;
  27 using mojo::ViewDataPtr;
  28
  29 namespace view_manager {
  30
  31 ViewManagerServiceImpl::ViewManagerServiceImpl(
  32     ConnectionManager* connection_manager,
  33     mojo::ConnectionSpecificId creator_id,
  34     const std::string& creator_url,
  35     const std::string& url,
  36     const ViewId& root_id)
  37     : connection_manager_(connection_manager),
  38       id_(connection_manager_->GetAndAdvanceNextConnectionId()),
  39       url_(url),
  40       creator_id_(creator_id),
  41       creator_url_(creator_url),
  42       client_(nullptr) {
  43   CHECK(GetView(root_id));
  44   root_.reset(new ViewId(root_id));
  45   if (root_id == RootViewId())
  46     access_policy_.reset(new WindowManagerAccessPolicy(id_, this));
  47   else
  48     access_policy_.reset(new DefaultAccessPolicy(id_, this));
  49 }
  50
  51 ViewManagerServiceImpl::~ViewManagerServiceImpl() {
  52   DestroyViews();
  53 }
  54
  55 void ViewManagerServiceImpl::Init(mojo::ViewManagerClient* client,
  56                                   mojo::ViewManagerServicePtr service_ptr,
  57                                   InterfaceRequest<ServiceProvider> services,
  58                                   ServiceProviderPtr exposed_services) {
  59   DCHECK(!client_);
  60   client_ = client;
  61   std::vector<const ServerView*> to_send;
  62   if (root_.get())
  63     GetUnknownViewsFrom(GetView(*root_), &to_send);
  64
  65   const ServerView* focused_view = connection_manager_->GetFocusedView();
  66   if (focused_view)
  67     focused_view = access_policy_->GetViewForFocusChange(focused_view);
  68   const mojo::Id focused_view_transport_id(
  69       ViewIdToTransportId(focused_view ? focused_view->id() : ViewId()));
  70
  71   client->OnEmbed(id_, creator_url_, ViewToViewData(to_send.front()),
  72                   service_ptr.Pass(), services.Pass(), exposed_services.Pass(),
  73                   focused_view_transport_id);
  74 }
  75
  76 const ServerView* ViewManagerServiceImpl::GetView(const ViewId& id) const {
  77   if (id_ == id.connection_id) {
  78     ViewMap::const_iterator i = view_map_.find(id.view_id);
  79     return i == view_map_.end() ? NULL : i->second;
  80   }
  81   return connection_manager_->GetView(id);
  82 }
  83
  84 bool ViewManagerServiceImpl::IsRoot(const ViewId& id) const {
  85   return root_.get() && *root_ == id;
  86 }
  87
  88 void ViewManagerServiceImpl::OnWillDestroyViewManagerServiceImpl(
  89     ViewManagerServiceImpl* connection) {
  90   if (creator_id_ == connection->id())
  91     creator_id_ = kInvalidConnectionId;
  92   if (connection->root_ && connection->root_->connection_id == id_ &&
  93       view_map_.count(connection->root_->view_id) > 0) {
  94     client()->OnEmbeddedAppDisconnected(
  95         ViewIdToTransportId(*connection->root_));
  96   }
  97   if (root_.get() && root_->connection_id == connection->id())
  98     root_.reset();
  99 }
 100
 101 mojo::ErrorCode ViewManagerServiceImpl::CreateView(const ViewId& view_id) {
 102   if (view_id.connection_id != id_)
 103     return mojo::ERROR_CODE_ILLEGAL_ARGUMENT;
 104   if (view_map_.find(view_id.view_id) != view_map_.end())
 105     return mojo::ERROR_CODE_VALUE_IN_USE;
 106   view_map_[view_id.view_id] = connection_manager_->CreateServerView(view_id);
 107   known_views_.insert(ViewIdToTransportId(view_id));
 108   return mojo::ERROR_CODE_NONE;
 109 }
 110
 111 bool ViewManagerServiceImpl::AddView(const ViewId& parent_id,
 112                                      const ViewId& child_id) {
 113   ServerView* parent = GetView(parent_id);
 114   ServerView* child = GetView(child_id);
 115   if (parent && child && child->parent() != parent &&
 116       !child->Contains(parent) && access_policy_->CanAddView(parent, child)) {
 117     ConnectionManager::ScopedChange change(this, connection_manager_, false);
 118     parent->Add(child);
 119     return true;
 120   }
 121   return false;
 122 }
 123
 124 std::vector<const ServerView*> ViewManagerServiceImpl::GetViewTree(
 125     const ViewId& view_id) const {
 126   const ServerView* view = GetView(view_id);
 127   std::vector<const ServerView*> views;
 128   if (view)
 129     GetViewTreeImpl(view, &views);
 130   return views;
 131 }
 132
 133 bool ViewManagerServiceImpl::SetViewVisibility(const ViewId& view_id,
 134                                                bool visible) {
 135   ServerView* view = GetView(view_id);
 136   if (!view || view->visible() == visible ||
 137       !access_policy_->CanChangeViewVisibility(view)) {
 138     return false;
 139   }
 140   ConnectionManager::ScopedChange change(this, connection_manager_, false);
 141   view->SetVisible(visible);
 142   return true;
 143 }
 144
 145 bool ViewManagerServiceImpl::EmbedUrl(
 146     const std::string& url,
 147     const ViewId& view_id,
 148     InterfaceRequest<ServiceProvider> services,
 149     ServiceProviderPtr exposed_services) {
 150   if (!PrepareForEmbed(view_id))
 151     return false;
 152   connection_manager_->EmbedAtView(id_, url, view_id, services.Pass(),
 153                                    exposed_services.Pass());
 154   return true;
 155 }
 156
 157 bool ViewManagerServiceImpl::Embed(const ViewId& view_id,
 158                                    mojo::ViewManagerClientPtr client) {
 159   if (!client.get() || !PrepareForEmbed(view_id))
 160     return false;
 161   connection_manager_->EmbedAtView(id_, view_id, client.Pass());
 162   return true;
 163 }
 164
 165 void ViewManagerServiceImpl::ProcessViewBoundsChanged(
 166     const ServerView* view,
 167     const gfx::Rect& old_bounds,
 168     const gfx::Rect& new_bounds,
 169     bool originated_change) {
 170   if (originated_change || !IsViewKnown(view))
 171     return;
 172   client()->OnViewBoundsChanged(ViewIdToTransportId(view->id()),
 173                                 Rect::From(old_bounds),
 174                                 Rect::From(new_bounds));
 175 }
 176
 177 void ViewManagerServiceImpl::ProcessViewportMetricsChanged(
 178     const mojo::ViewportMetrics& old_metrics,
 179     const mojo::ViewportMetrics& new_metrics,
 180     bool originated_change) {
 181   client()->OnViewViewportMetricsChanged(old_metrics.Clone(),
 182                                          new_metrics.Clone());
 183 }
 184
 185 void ViewManagerServiceImpl::ProcessWillChangeViewHierarchy(
 186     const ServerView* view,
 187     const ServerView* new_parent,
 188     const ServerView* old_parent,
 189     bool originated_change) {
 190   if (originated_change)
 191     return;
 192
 193   const bool old_drawn = view->IsDrawn(connection_manager_->root());
 194   const bool new_drawn = view->visible() && new_parent &&
 195       new_parent->IsDrawn(connection_manager_->root());
 196   if (old_drawn == new_drawn)
 197     return;
 198
 199   NotifyDrawnStateChanged(view, new_drawn);
 200 }
 201
 202 void ViewManagerServiceImpl::ProcessViewPropertyChanged(
 203     const ServerView* view,
 204     const std::string& name,
 205     const std::vector<uint8_t>* new_data,
 206     bool originated_change) {
 207   if (originated_change)
 208     return;
 209
 210   Array<uint8_t> data;
 211   if (new_data)
 212     data = Array<uint8_t>::From(*new_data);
 213
 214   client()->OnViewSharedPropertyChanged(ViewIdToTransportId(view->id()),
 215                                         String(name), data.Pass());
 216 }
 217
 218 void ViewManagerServiceImpl::ProcessViewHierarchyChanged(
 219     const ServerView* view,
 220     const ServerView* new_parent,
 221     const ServerView* old_parent,
 222     bool originated_change) {
 223   if (originated_change && !IsViewKnown(view) && new_parent &&
 224       IsViewKnown(new_parent)) {
 225     std::vector<const ServerView*> unused;
 226     GetUnknownViewsFrom(view, &unused);
 227   }
 228   if (originated_change || connection_manager_->is_processing_delete_view() ||
 229       connection_manager_->DidConnectionMessageClient(id_)) {
 230     return;
 231   }
 232
 233   if (!access_policy_->ShouldNotifyOnHierarchyChange(
 234           view, &new_parent, &old_parent)) {
 235     return;
 236   }
 237   // Inform the client of any new views and update the set of views we know
 238   // about.
 239   std::vector<const ServerView*> to_send;
 240   if (!IsViewKnown(view))
 241     GetUnknownViewsFrom(view, &to_send);
 242   const ViewId new_parent_id(new_parent ? new_parent->id() : ViewId());
 243   const ViewId old_parent_id(old_parent ? old_parent->id() : ViewId());
 244   client()->OnViewHierarchyChanged(ViewIdToTransportId(view->id()),
 245                                    ViewIdToTransportId(new_parent_id),
 246                                    ViewIdToTransportId(old_parent_id),
 247                                    ViewsToViewDatas(to_send));
 248   connection_manager_->OnConnectionMessagedClient(id_);
 249 }
 250
 251 void ViewManagerServiceImpl::ProcessViewReorder(const ServerView* view,
 252                                                 const ServerView* relative_view,
 253                                                 OrderDirection direction,
 254                                                 bool originated_change) {
 255   if (originated_change || !IsViewKnown(view) || !IsViewKnown(relative_view))
 256     return;
 257
 258   client()->OnViewReordered(ViewIdToTransportId(view->id()),
 259                             ViewIdToTransportId(relative_view->id()),
 260                             direction);
 261 }
 262
 263 void ViewManagerServiceImpl::ProcessViewDeleted(const ViewId& view,
 264                                                 bool originated_change) {
 265   if (view.connection_id == id_)
 266     view_map_.erase(view.view_id);
 267
 268   const bool in_known = known_views_.erase(ViewIdToTransportId(view)) > 0;
 269
 270   if (IsRoot(view))
 271     root_.reset();
 272
 273   if (originated_change)
 274     return;
 275
 276   if (in_known) {
 277     client()->OnViewDeleted(ViewIdToTransportId(view));
 278     connection_manager_->OnConnectionMessagedClient(id_);
 279   }
 280 }
 281
 282 void ViewManagerServiceImpl::ProcessWillChangeViewVisibility(
 283     const ServerView* view,
 284     bool originated_change) {
 285   if (originated_change)
 286     return;
 287
 288   if (IsViewKnown(view)) {
 289     client()->OnViewVisibilityChanged(ViewIdToTransportId(view->id()),
 290                                       !view->visible());
 291     return;
 292   }
 293
 294   bool view_target_drawn_state;
 295   if (view->visible()) {
 296     // View is being hidden, won't be drawn.
 297     view_target_drawn_state = false;
 298   } else {
 299     // View is being shown. View will be drawn if its parent is drawn.
 300     view_target_drawn_state =
 301         view->parent() && view->parent()->IsDrawn(connection_manager_->root());
 302   }
 303
 304   NotifyDrawnStateChanged(view, view_target_drawn_state);
 305 }
 306
 307 void ViewManagerServiceImpl::ProcessFocusChanged(
 308     const ServerView* old_focused_view,
 309     const ServerView* new_focused_view) {
 310   const ServerView* view =
 311       new_focused_view ? access_policy_->GetViewForFocusChange(new_focused_view)
 312                        : nullptr;
 313   client()->OnViewFocused(view ? ViewIdToTransportId(view->id())
 314                                : ViewIdToTransportId(ViewId()));
 315 }
 316
 317 bool ViewManagerServiceImpl::IsViewKnown(const ServerView* view) const {
 318   return known_views_.count(ViewIdToTransportId(view->id())) > 0;
 319 }
 320
 321 bool ViewManagerServiceImpl::CanReorderView(const ServerView* view,
 322                                             const ServerView* relative_view,
 323                                             OrderDirection direction) const {
 324   if (!view || !relative_view)
 325     return false;
 326
 327   if (!view->parent() || view->parent() != relative_view->parent())
 328     return false;
 329
 330   if (!access_policy_->CanReorderView(view, relative_view, direction))
 331     return false;
 332
 333   std::vector<const ServerView*> children = view->parent()->GetChildren();
 334   const size_t child_i =
 335       std::find(children.begin(), children.end(), view) - children.begin();
 336   const size_t target_i =
 337       std::find(children.begin(), children.end(), relative_view) -
 338       children.begin();
 339   if ((direction == mojo::ORDER_DIRECTION_ABOVE && child_i == target_i + 1) ||
 340       (direction == mojo::ORDER_DIRECTION_BELOW && child_i + 1 == target_i)) {
 341     return false;
 342   }
 343
 344   return true;
 345 }
 346
 347 bool ViewManagerServiceImpl::DeleteViewImpl(ViewManagerServiceImpl* source,
 348                                             ServerView* view) {
 349   DCHECK(view);
 350   DCHECK_EQ(view->id().connection_id, id_);
 351   ConnectionManager::ScopedChange change(source, connection_manager_, true);
 352   delete view;
 353   return true;
 354 }
 355
 356 void ViewManagerServiceImpl::GetUnknownViewsFrom(
 357     const ServerView* view,
 358     std::vector<const ServerView*>* views) {
 359   if (IsViewKnown(view) || !access_policy_->CanGetViewTree(view))
 360     return;
 361   views->push_back(view);
 362   known_views_.insert(ViewIdToTransportId(view->id()));
 363   if (!access_policy_->CanDescendIntoViewForViewTree(view))
 364     return;
 365   std::vector<const ServerView*> children(view->GetChildren());
 366   for (size_t i = 0 ; i < children.size(); ++i)
 367     GetUnknownViewsFrom(children[i], views);
 368 }
 369
 370 void ViewManagerServiceImpl::RemoveFromKnown(
 371     const ServerView* view,
 372     std::vector<ServerView*>* local_views) {
 373   if (view->id().connection_id == id_) {
 374     if (local_views)
 375       local_views->push_back(GetView(view->id()));
 376     return;
 377   }
 378   known_views_.erase(ViewIdToTransportId(view->id()));
 379   std::vector<const ServerView*> children = view->GetChildren();
 380   for (size_t i = 0; i < children.size(); ++i)
 381     RemoveFromKnown(children[i], local_views);
 382 }
 383
 384 void ViewManagerServiceImpl::RemoveRoot() {
 385   CHECK(root_.get());
 386   const ViewId root_id(*root_);
 387   root_.reset();
 388   // No need to do anything if we created the view.
 389   if (root_id.connection_id == id_)
 390     return;
 391
 392   client()->OnViewDeleted(ViewIdToTransportId(root_id));
 393   connection_manager_->OnConnectionMessagedClient(id_);
 394
 395   // This connection no longer knows about the view. Unparent any views that
 396   // were parented to views in the root.
 397   std::vector<ServerView*> local_views;
 398   RemoveFromKnown(GetView(root_id), &local_views);
 399   for (size_t i = 0; i < local_views.size(); ++i)
 400     local_views[i]->parent()->Remove(local_views[i]);
 401 }
 402
 403 void ViewManagerServiceImpl::RemoveChildrenAsPartOfEmbed(
 404     const ViewId& view_id) {
 405   ServerView* view = GetView(view_id);
 406   CHECK(view);
 407   CHECK(view->id().connection_id == view_id.connection_id);
 408   std::vector<ServerView*> children = view->GetChildren();
 409   for (size_t i = 0; i < children.size(); ++i)
 410     view->Remove(children[i]);
 411 }
 412
 413 Array<ViewDataPtr> ViewManagerServiceImpl::ViewsToViewDatas(
 414     const std::vector<const ServerView*>& views) {
 415   Array<ViewDataPtr> array(views.size());
 416   for (size_t i = 0; i < views.size(); ++i)
 417     array[i] = ViewToViewData(views[i]).Pass();
 418   return array.Pass();
 419 }
 420
 421 ViewDataPtr ViewManagerServiceImpl::ViewToViewData(const ServerView* view) {
 422   DCHECK(IsViewKnown(view));
 423   const ServerView* parent = view->parent();
 424   // If the parent isn't known, it means the parent is not visible to us (not
 425   // in roots), and should not be sent over.
 426   if (parent && !IsViewKnown(parent))
 427     parent = NULL;
 428   ViewDataPtr view_data(mojo::ViewData::New());
 429   view_data->parent_id = ViewIdToTransportId(parent ? parent->id() : ViewId());
 430   view_data->view_id = ViewIdToTransportId(view->id());
 431   view_data->bounds = Rect::From(view->bounds());
 432   view_data->properties =
 433       mojo::Map<String, Array<uint8_t>>::From(view->properties());
 434   view_data->visible = view->visible();
 435   view_data->drawn = view->IsDrawn(connection_manager_->root());
 436   view_data->viewport_metrics =
 437       connection_manager_->display_manager()->GetViewportMetrics().Clone();
 438   return view_data.Pass();
 439 }
 440
 441 void ViewManagerServiceImpl::GetViewTreeImpl(
 442     const ServerView* view,
 443     std::vector<const ServerView*>* views) const {
 444   DCHECK(view);
 445
 446   if (!access_policy_->CanGetViewTree(view))
 447     return;
 448
 449   views->push_back(view);
 450
 451   if (!access_policy_->CanDescendIntoViewForViewTree(view))
 452     return;
 453
 454   std::vector<const ServerView*> children(view->GetChildren());
 455   for (size_t i = 0 ; i < children.size(); ++i)
 456     GetViewTreeImpl(children[i], views);
 457 }
 458
 459 void ViewManagerServiceImpl::NotifyDrawnStateChanged(const ServerView* view,
 460                                                      bool new_drawn_value) {
 461   // Even though we don't know about view, it may be an ancestor of our root, in
 462   // which case the change may effect our roots drawn state.
 463   if (!root_.get())
 464     return;
 465
 466   const ServerView* root = GetView(*root_);
 467   DCHECK(root);
 468   if (view->Contains(root) &&
 469       (new_drawn_value != root->IsDrawn(connection_manager_->root()))) {
 470     client()->OnViewDrawnStateChanged(ViewIdToTransportId(root->id()),
 471                                       new_drawn_value);
 472   }
 473 }
 474
 475 void ViewManagerServiceImpl::DestroyViews() {
 476   if (!view_map_.empty()) {
 477     ConnectionManager::ScopedChange change(this, connection_manager_, true);
 478     // If we get here from the destructor we're not going to get
 479     // ProcessViewDeleted(). Copy the map and delete from the copy so that we
 480     // don't have to worry about whether |view_map_| changes or not.
 481     ViewMap view_map_copy;
 482     view_map_.swap(view_map_copy);
 483     STLDeleteValues(&view_map_copy);
 484   }
 485 }
 486
 487 bool ViewManagerServiceImpl::PrepareForEmbed(const ViewId& view_id) {
 488   const ServerView* view = GetView(view_id);
 489   if (!view || !access_policy_->CanEmbed(view))
 490     return false;
 491
 492   // Only allow a node to be the root for one connection.
 493   ViewManagerServiceImpl* existing_owner =
 494       connection_manager_->GetConnectionWithRoot(view_id);
 495
 496   ConnectionManager::ScopedChange change(this, connection_manager_, true);
 497   RemoveChildrenAsPartOfEmbed(view_id);
 498   if (existing_owner) {
 499     // Never message the originating connection.
 500     connection_manager_->OnConnectionMessagedClient(id_);
 501     existing_owner->RemoveRoot();
 502   }
 503   return true;
 504 }
 505
 506 void ViewManagerServiceImpl::CreateView(
 507     Id transport_view_id,
 508     const Callback<void(mojo::ErrorCode)>& callback) {
 509   callback.Run(CreateView(ViewIdFromTransportId(transport_view_id)));
 510 }
 511
 512 void ViewManagerServiceImpl::DeleteView(
 513     Id transport_view_id,
 514     const Callback<void(bool)>& callback) {
 515   ServerView* view = GetView(ViewIdFromTransportId(transport_view_id));
 516   bool success = false;
 517   if (view && access_policy_->CanDeleteView(view)) {
 518     ViewManagerServiceImpl* connection =
 519         connection_manager_->GetConnection(view->id().connection_id);
 520     success = connection && connection->DeleteViewImpl(this, view);
 521   }
 522   callback.Run(success);
 523 }
 524
 525 void ViewManagerServiceImpl::AddView(
 526     Id parent_id,
 527     Id child_id,
 528     const Callback<void(bool)>& callback) {
 529   callback.Run(AddView(ViewIdFromTransportId(parent_id),
 530                        ViewIdFromTransportId(child_id)));
 531 }
 532
 533 void ViewManagerServiceImpl::RemoveViewFromParent(
 534     Id view_id,
 535     const Callback<void(bool)>& callback) {
 536   bool success = false;
 537   ServerView* view = GetView(ViewIdFromTransportId(view_id));
 538   if (view && view->parent() && access_policy_->CanRemoveViewFromParent(view)) {
 539     success = true;
 540     ConnectionManager::ScopedChange change(this, connection_manager_, false);
 541     view->parent()->Remove(view);
 542   }
 543   callback.Run(success);
 544 }
 545
 546 void ViewManagerServiceImpl::ReorderView(Id view_id,
 547                                          Id relative_view_id,
 548                                          OrderDirection direction,
 549                                          const Callback<void(bool)>& callback) {
 550   bool success = false;
 551   ServerView* view = GetView(ViewIdFromTransportId(view_id));
 552   ServerView* relative_view = GetView(ViewIdFromTransportId(relative_view_id));
 553   if (CanReorderView(view, relative_view, direction)) {
 554     success = true;
 555     ConnectionManager::ScopedChange change(this, connection_manager_, false);
 556     view->parent()->Reorder(view, relative_view, direction);
 557     connection_manager_->ProcessViewReorder(view, relative_view, direction);
 558   }
 559   callback.Run(success);
 560 }
 561
 562 void ViewManagerServiceImpl::GetViewTree(
 563     Id view_id,
 564     const Callback<void(Array<ViewDataPtr>)>& callback) {
 565   std::vector<const ServerView*> views(
 566       GetViewTree(ViewIdFromTransportId(view_id)));
 567   callback.Run(ViewsToViewDatas(views));
 568 }
 569
 570 void ViewManagerServiceImpl::SetViewSurfaceId(
 571     Id view_id,
 572     mojo::SurfaceIdPtr surface_id,
 573     const Callback<void(bool)>& callback) {
 574   // TODO(sky): add coverage of not being able to set for random node.
 575   ServerView* view = GetView(ViewIdFromTransportId(view_id));
 576   if (!view || !access_policy_->CanSetViewSurfaceId(view)) {
 577     callback.Run(false);
 578     return;
 579   }
 580   view->SetSurfaceId(surface_id.To<cc::SurfaceId>());
 581   callback.Run(true);
 582 }
 583
 584 void ViewManagerServiceImpl::SetViewBounds(
 585     Id view_id,
 586     mojo::RectPtr bounds,
 587     const Callback<void(bool)>& callback) {
 588   ServerView* view = GetView(ViewIdFromTransportId(view_id));
 589   const bool success = view && access_policy_->CanSetViewBounds(view);
 590   if (success) {
 591     ConnectionManager::ScopedChange change(this, connection_manager_, false);
 592     view->SetBounds(bounds.To<gfx::Rect>());
 593   }
 594   callback.Run(success);
 595 }
 596
 597 void ViewManagerServiceImpl::SetViewVisibility(
 598     Id transport_view_id,
 599     bool visible,
 600     const Callback<void(bool)>& callback) {
 601   callback.Run(
 602       SetViewVisibility(ViewIdFromTransportId(transport_view_id), visible));
 603 }
 604
 605 void ViewManagerServiceImpl::SetViewProperty(
 606     uint32_t view_id,
 607     const mojo::String& name,
 608     mojo::Array<uint8_t> value,
 609     const mojo::Callback<void(bool)>& callback) {
 610   ServerView* view = GetView(ViewIdFromTransportId(view_id));
 611   const bool success = view && access_policy_->CanSetViewProperties(view);
 612   if (success) {
 613     ConnectionManager::ScopedChange change(this, connection_manager_, false);
 614
 615     if (value.is_null()) {
 616       view->SetProperty(name, nullptr);
 617     } else {
 618       std::vector<uint8_t> data = value.To<std::vector<uint8_t>>();
 619       view->SetProperty(name, &data);
 620     }
 621   }
 622   callback.Run(success);
 623 }
 624
 625 void ViewManagerServiceImpl::EmbedUrl(
 626     const String& url,
 627     Id transport_view_id,
 628     InterfaceRequest<ServiceProvider> services,
 629     ServiceProviderPtr exposed_services,
 630     const Callback<void(bool)>& callback) {
 631   callback.Run(EmbedUrl(url.To<std::string>(),
 632                         ViewIdFromTransportId(transport_view_id),
 633                         services.Pass(), exposed_services.Pass()));
 634 }
 635
 636 void ViewManagerServiceImpl::Embed(mojo::Id transport_view_id,
 637                                    mojo::ViewManagerClientPtr client,
 638                                    const mojo::Callback<void(bool)>& callback) {
 639   callback.Run(Embed(ViewIdFromTransportId(transport_view_id), client.Pass()));
 640 }
 641
 642 void ViewManagerServiceImpl::SetFocus(uint32_t view_id,
 643                                       const SetFocusCallback& callback) {
 644   ServerView* view = GetView(ViewIdFromTransportId(view_id));
 645   bool success = view && view->IsDrawn(connection_manager_->root()) &&
 646                  access_policy_->CanSetFocus(view);
 647   if (success) {
 648     ConnectionManager::ScopedChange change(this, connection_manager_, false);
 649     connection_manager_->SetFocusedView(view);
 650   }
 651   callback.Run(success);
 652 }
 653
 654 bool ViewManagerServiceImpl::IsRootForAccessPolicy(const ViewId& id) const {
 655   return IsRoot(id);
 656 }
 657
 658 bool ViewManagerServiceImpl::IsViewKnownForAccessPolicy(
 659     const ServerView* view) const {
 660   return IsViewKnown(view);
 661 }
 662
 663 bool ViewManagerServiceImpl::IsViewRootOfAnotherConnectionForAccessPolicy(
 664     const ServerView* view) const {
 665   ViewManagerServiceImpl* connection =
 666       connection_manager_->GetConnectionWithRoot(view->id());
 667   return connection && connection != this;
 668 }
 669
 670 }  // namespace view_manager