examples/ui/tile/tile_view.cc - mojo-tools - Git at Google

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "examples/ui/tile/tile_view.h"
 #include "mojo/services/surfaces/cpp/surfaces_utils.h"
 #include "mojo/services/surfaces/interfaces/quads.mojom.h"

 namespace examples {

 TileView::TileView(mojo::ApplicationImpl* app_impl,
                    const std::vector<std::string>& view_urls,
                    const mojo::ui::ViewProvider::CreateViewCallback& callback)
     : app_impl_(app_impl),
       view_urls_(view_urls),
       callback_(callback),
       binding_(this),
       surface_id_namespace_(0),
       pending_child_layout_count_(0),
       frame_pending_(false),
       weak_ptr_factory_(this) {
   app_impl_->ConnectToService("mojo:surfaces_service", &surfaces_);
   app_impl_->ConnectToService("mojo:view_manager_service", &view_manager_);

   surfaces_->GetIdNamespace(base::Bind(&TileView::OnSurfaceIdNamespaceAvailable,
                                        base::Unretained(this)));
 }

 TileView::~TileView() {}

 void TileView::OnSurfaceIdNamespaceAvailable(uint32_t id_namespace) {
   surface_id_namespace_ = id_namespace;
   InitView();
 }

 void TileView::InitView() {
   // Register the view.
   mojo::ui::ViewPtr view;
   binding_.Bind(mojo::GetProxy(&view));
   view_manager_->RegisterView(view.Pass(), mojo::GetProxy(&view_host_),
                               callback_);

   // Connect to all child views.
   uint32_t child_key = 0;
   for (const auto& url : view_urls_) {
     // Start connecting to the view provider.
     mojo::ui::ViewProviderPtr provider;
     app_impl_->ConnectToService(url, &provider);
     provider.set_connection_error_handler(
         base::Bind(&TileView::OnChildConnectionError, base::Unretained(this),
                    child_key, url));

     // Create the view.
     // We include the provider reference in the callback so that the
     // binding will be kept alive until the callback completes.
     LOG(INFO) << "Connecting to view: child_key=" << child_key
               << ", url=" << url;
     provider->CreateView(
         nullptr, nullptr,
         base::Bind(&TileView::OnChildCreated, base::Unretained(this), child_key,
                    url, base::Passed(provider.Pass())));
     child_key++;
   }
 }

 void TileView::OnChildConnectionError(uint32_t child_key,
                                       const std::string& url) {
   LOG(ERROR) << "Could not connect to view: child_key=" << child_key
              << ", url=" << url;
 }

 void TileView::OnChildCreated(uint32_t child_key,
                               const std::string& url,
                               mojo::ui::ViewProviderPtr provider,
                               mojo::ui::ViewTokenPtr token) {
   DCHECK(views_.find(child_key) == views_.end());
   LOG(INFO) << "View created: child_key=" << child_key << ", url=" << url;

   view_host_->AddChild(child_key, token.Pass());
   views_.emplace(
       std::make_pair(child_key, std::unique_ptr<ViewData>(new ViewData(url))));

   // Note that the view provider will be destroyed once this function
   // returns which is fine now that we are done creating the view.
 }

 void TileView::OnChildUnavailable(uint32_t child_key,
                                   const OnChildUnavailableCallback& callback) {
   auto it = views_.find(child_key);
   DCHECK(it != views_.end());
   LOG(ERROR) << "View died unexpectedly: child_key=" << child_key
              << ", url=" << it->second->url;

   std::unique_ptr<ViewData> view_data = std::move(it->second);
   views_.erase(it);

   view_host_->RemoveChild(child_key);

   if (view_data->layout_pending) {
     DCHECK(pending_child_layout_count_);
     pending_child_layout_count_--;
     FinishLayout();
   }

   callback.Run();
 }

 void TileView::OnLayout(mojo::ui::ViewLayoutParamsPtr layout_params,
                         mojo::Array<uint32_t> children_needing_layout,
                         const OnLayoutCallback& callback) {
   // Create a new surface the first time or if the size has changed.
   mojo::Size new_size;
   new_size.width = layout_params->constraints->max_width;
   new_size.height = layout_params->constraints->max_height;
   if (!surface_id_ || !size_.Equals(new_size)) {
     if (!surface_id_) {
       surface_id_ = mojo::SurfaceId::New();
       surface_id_->id_namespace = surface_id_namespace_;
     } else {
       surfaces_->DestroySurface(surface_id_->local);
     }
     surface_id_->local++;
     size_ = new_size;
     surfaces_->CreateSurface(surface_id_->local);
   }

   // Wipe out cached layout information for children needing layout.
   for (uint32_t child_key : children_needing_layout) {
     auto view_it = views_.find(child_key);
     if (view_it != views_.end())
       view_it->second->layout_info.reset();
   }

   // Layout all children in a row.
   if (!views_.empty()) {
     uint32_t index = 0;
     uint32_t base_width = new_size.width / views_.size();
     uint32_t excess_width = new_size.width % views_.size();
     uint32_t x = 0;
     for (auto it = views_.begin(); it != views_.end(); ++it, ++index) {
       ViewData* view_data = it->second.get();
       DCHECK(!view_data->layout_pending);

       // Distribute any excess width among the leading children.
       uint32_t child_width = base_width;
       if (excess_width) {
         child_width++;
         excess_width--;
       }
       uint32_t child_height = new_size.height;
       uint32_t child_x = x;
       x += child_width;

       view_data->layout_bounds.x = child_x;
       view_data->layout_bounds.y = 0;
       view_data->layout_bounds.width = child_width;
       view_data->layout_bounds.height = child_height;

       mojo::ui::ViewLayoutParamsPtr params = mojo::ui::ViewLayoutParams::New();
       params->constraints = mojo::ui::BoxConstraints::New();
       params->constraints->min_width = child_width;
       params->constraints->max_width = child_width;
       params->constraints->min_height = child_height;
       params->constraints->max_height = child_height;
       params->device_pixel_ratio = layout_params->device_pixel_ratio;

       if (view_data->layout_info && view_data->layout_params.Equals(params))
         continue;  // no layout work to do

       pending_child_layout_count_++;
       view_data->layout_pending = true;
       view_data->layout_params = params.Clone();
       view_data->layout_info.reset();

       view_host_->LayoutChild(it->first, params.Pass(),
                               base::Bind(&TileView::OnChildLayoutFinished,
                                          base::Unretained(this), it->first));
     }
   }

   // Store the callback until layout of all children is finished.
   pending_layout_callback_ = callback;
   FinishLayout();
 }

 void TileView::OnChildLayoutFinished(
     uint32_t child_key,
     mojo::ui::ViewLayoutInfoPtr child_layout_info) {
   auto it = views_.find(child_key);
   if (it != views_.end()) {
     ViewData* view_data = it->second.get();
     DCHECK(view_data->layout_pending);
     DCHECK(pending_child_layout_count_);
     pending_child_layout_count_--;
     view_data->layout_pending = false;
     view_data->layout_info = child_layout_info.Pass();
     FinishLayout();
   }
 }

 void TileView::FinishLayout() {
   if (frame_pending_ || pending_layout_callback_.is_null())
     return;

   // Wait until all children have laid out.
   // TODO(jeffbrown): There should be a timeout on this.
   if (pending_child_layout_count_)
     return;

   // Produce a new frame.
   mojo::FramePtr frame = mojo::Frame::New();
   frame->resources.resize(0u);

   mojo::Rect bounds;
   bounds.width = size_.width;
   bounds.height = size_.height;
   mojo::PassPtr pass = mojo::CreateDefaultPass(1, bounds);
   pass->shared_quad_states.resize(0u);
   pass->quads.resize(0u);

   for (auto it = views_.cbegin(); it != views_.cend(); it++) {
     const ViewData& view_data = *(it->second.get());

     mojo::QuadPtr quad = mojo::Quad::New();
     quad->rect = view_data.layout_bounds.Clone();
     quad->rect->x = 0;
     quad->rect->y = 0;
     quad->opaque_rect = quad->rect.Clone();
     quad->visible_rect = quad->rect.Clone();
     quad->shared_quad_state_index = pass->shared_quad_states.size();

     mojo::Size size;
     size.width = view_data.layout_bounds.width;
     size.height = view_data.layout_bounds.height;

     mojo::SharedQuadStatePtr quad_state = mojo::CreateDefaultSQS(size);
     quad_state->content_to_target_transform->matrix[3] =
         view_data.layout_bounds.x;
     pass->shared_quad_states.push_back(quad_state.Pass());

     if (it->second->layout_info) {
       quad->material = mojo::Material::SURFACE_CONTENT;
       quad->surface_quad_state = mojo::SurfaceQuadState::New();
       quad->surface_quad_state->surface =
           view_data.layout_info->surface_id.Clone();
     } else {
       quad->material = mojo::Material::SOLID_COLOR;
       quad->solid_color_quad_state = mojo::SolidColorQuadState::New();
       quad->solid_color_quad_state->color = mojo::Color::New();
       quad->solid_color_quad_state->color->rgba = 0xffff00ff;
     }

     pass->quads.push_back(quad.Pass());
   }

   frame->passes.push_back(pass.Pass());

   frame_pending_ = true;
   surfaces_->SubmitFrame(
       surface_id_->local, frame.Pass(),
       base::Bind(&TileView::OnFrameSubmitted, base::Unretained(this)));

   // Submit the new layout information.
   mojo::ui::ViewLayoutInfoPtr info = mojo::ui::ViewLayoutInfo::New();
   info->size = size_.Clone();
   info->surface_id = surface_id_->Clone();
   pending_layout_callback_.Run(info.Pass());
   pending_layout_callback_.reset();
 }

 void TileView::OnFrameSubmitted() {
   DCHECK(frame_pending_);

   frame_pending_ = false;
   FinishLayout();
 }

 TileView::ViewData::ViewData(const std::string& url)
     : url(url), layout_pending(false) {}

 TileView::ViewData::~ViewData() {}

 }  // namespace examples
	// Copyright 2015 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "examples/ui/tile/tile_view.h"
	#include "mojo/services/surfaces/cpp/surfaces_utils.h"
	#include "mojo/services/surfaces/interfaces/quads.mojom.h"

	namespace examples {

	TileView::TileView(mojo::ApplicationImpl* app_impl,
	const std::vector<std::string>& view_urls,
	const mojo::ui::ViewProvider::CreateViewCallback& callback)
	: app_impl_(app_impl),
	view_urls_(view_urls),
	callback_(callback),
	binding_(this),
	surface_id_namespace_(0),
	pending_child_layout_count_(0),
	frame_pending_(false),
	weak_ptr_factory_(this) {
	app_impl_->ConnectToService("mojo:surfaces_service", &surfaces_);
	app_impl_->ConnectToService("mojo:view_manager_service", &view_manager_);

	surfaces_->GetIdNamespace(base::Bind(&TileView::OnSurfaceIdNamespaceAvailable,
	base::Unretained(this)));
	}

	TileView::~TileView() {}

	void TileView::OnSurfaceIdNamespaceAvailable(uint32_t id_namespace) {
	surface_id_namespace_ = id_namespace;
	InitView();
	}

	void TileView::InitView() {
	// Register the view.
	mojo::ui::ViewPtr view;
	binding_.Bind(mojo::GetProxy(&view));
	view_manager_->RegisterView(view.Pass(), mojo::GetProxy(&view_host_),
	callback_);

	// Connect to all child views.
	uint32_t child_key = 0;
	for (const auto& url : view_urls_) {
	// Start connecting to the view provider.
	mojo::ui::ViewProviderPtr provider;
	app_impl_->ConnectToService(url, &provider);
	provider.set_connection_error_handler(
	base::Bind(&TileView::OnChildConnectionError, base::Unretained(this),
	child_key, url));

	// Create the view.
	// We include the provider reference in the callback so that the
	// binding will be kept alive until the callback completes.
	LOG(INFO) << "Connecting to view: child_key=" << child_key
	<< ", url=" << url;
	provider->CreateView(
	nullptr, nullptr,
	base::Bind(&TileView::OnChildCreated, base::Unretained(this), child_key,
	url, base::Passed(provider.Pass())));
	child_key++;
	}
	}

	void TileView::OnChildConnectionError(uint32_t child_key,
	const std::string& url) {
	LOG(ERROR) << "Could not connect to view: child_key=" << child_key
	<< ", url=" << url;
	}

	void TileView::OnChildCreated(uint32_t child_key,
	const std::string& url,
	mojo::ui::ViewProviderPtr provider,
	mojo::ui::ViewTokenPtr token) {
	DCHECK(views_.find(child_key) == views_.end());
	LOG(INFO) << "View created: child_key=" << child_key << ", url=" << url;

	view_host_->AddChild(child_key, token.Pass());
	views_.emplace(
	std::make_pair(child_key, std::unique_ptr<ViewData>(new ViewData(url))));

	// Note that the view provider will be destroyed once this function
	// returns which is fine now that we are done creating the view.
	}

	void TileView::OnChildUnavailable(uint32_t child_key,
	const OnChildUnavailableCallback& callback) {
	auto it = views_.find(child_key);
	DCHECK(it != views_.end());
	LOG(ERROR) << "View died unexpectedly: child_key=" << child_key
	<< ", url=" << it->second->url;

	std::unique_ptr<ViewData> view_data = std::move(it->second);
	views_.erase(it);

	view_host_->RemoveChild(child_key);

	if (view_data->layout_pending) {
	DCHECK(pending_child_layout_count_);
	pending_child_layout_count_--;
	FinishLayout();
	}

	callback.Run();
	}

	void TileView::OnLayout(mojo::ui::ViewLayoutParamsPtr layout_params,
	mojo::Array<uint32_t> children_needing_layout,
	const OnLayoutCallback& callback) {
	// Create a new surface the first time or if the size has changed.
	mojo::Size new_size;
	new_size.width = layout_params->constraints->max_width;
	new_size.height = layout_params->constraints->max_height;
	if (!surface_id_ \|\| !size_.Equals(new_size)) {
	if (!surface_id_) {
	surface_id_ = mojo::SurfaceId::New();
	surface_id_->id_namespace = surface_id_namespace_;
	} else {
	surfaces_->DestroySurface(surface_id_->local);
	}
	surface_id_->local++;
	size_ = new_size;
	surfaces_->CreateSurface(surface_id_->local);
	}

	// Wipe out cached layout information for children needing layout.
	for (uint32_t child_key : children_needing_layout) {
	auto view_it = views_.find(child_key);
	if (view_it != views_.end())
	view_it->second->layout_info.reset();
	}

	// Layout all children in a row.
	if (!views_.empty()) {
	uint32_t index = 0;
	uint32_t base_width = new_size.width / views_.size();
	uint32_t excess_width = new_size.width % views_.size();
	uint32_t x = 0;
	for (auto it = views_.begin(); it != views_.end(); ++it, ++index) {
	ViewData* view_data = it->second.get();
	DCHECK(!view_data->layout_pending);

	// Distribute any excess width among the leading children.
	uint32_t child_width = base_width;
	if (excess_width) {
	child_width++;
	excess_width--;
	}
	uint32_t child_height = new_size.height;
	uint32_t child_x = x;
	x += child_width;

	view_data->layout_bounds.x = child_x;
	view_data->layout_bounds.y = 0;
	view_data->layout_bounds.width = child_width;
	view_data->layout_bounds.height = child_height;

	mojo::ui::ViewLayoutParamsPtr params = mojo::ui::ViewLayoutParams::New();
	params->constraints = mojo::ui::BoxConstraints::New();
	params->constraints->min_width = child_width;
	params->constraints->max_width = child_width;
	params->constraints->min_height = child_height;
	params->constraints->max_height = child_height;
	params->device_pixel_ratio = layout_params->device_pixel_ratio;

	if (view_data->layout_info && view_data->layout_params.Equals(params))
	continue; // no layout work to do

	pending_child_layout_count_++;
	view_data->layout_pending = true;
	view_data->layout_params = params.Clone();
	view_data->layout_info.reset();

	view_host_->LayoutChild(it->first, params.Pass(),
	base::Bind(&TileView::OnChildLayoutFinished,
	base::Unretained(this), it->first));
	}
	}

	// Store the callback until layout of all children is finished.
	pending_layout_callback_ = callback;
	FinishLayout();
	}

	void TileView::OnChildLayoutFinished(
	uint32_t child_key,
	mojo::ui::ViewLayoutInfoPtr child_layout_info) {
	auto it = views_.find(child_key);
	if (it != views_.end()) {
	ViewData* view_data = it->second.get();
	DCHECK(view_data->layout_pending);
	DCHECK(pending_child_layout_count_);
	pending_child_layout_count_--;
	view_data->layout_pending = false;
	view_data->layout_info = child_layout_info.Pass();
	FinishLayout();
	}
	}

	void TileView::FinishLayout() {
	if (frame_pending_ \|\| pending_layout_callback_.is_null())
	return;

	// Wait until all children have laid out.
	// TODO(jeffbrown): There should be a timeout on this.
	if (pending_child_layout_count_)
	return;

	// Produce a new frame.
	mojo::FramePtr frame = mojo::Frame::New();
	frame->resources.resize(0u);

	mojo::Rect bounds;
	bounds.width = size_.width;
	bounds.height = size_.height;
	mojo::PassPtr pass = mojo::CreateDefaultPass(1, bounds);
	pass->shared_quad_states.resize(0u);
	pass->quads.resize(0u);

	for (auto it = views_.cbegin(); it != views_.cend(); it++) {
	const ViewData& view_data = *(it->second.get());

	mojo::QuadPtr quad = mojo::Quad::New();
	quad->rect = view_data.layout_bounds.Clone();
	quad->rect->x = 0;
	quad->rect->y = 0;
	quad->opaque_rect = quad->rect.Clone();
	quad->visible_rect = quad->rect.Clone();
	quad->shared_quad_state_index = pass->shared_quad_states.size();

	mojo::Size size;
	size.width = view_data.layout_bounds.width;
	size.height = view_data.layout_bounds.height;

	mojo::SharedQuadStatePtr quad_state = mojo::CreateDefaultSQS(size);
	quad_state->content_to_target_transform->matrix[3] =
	view_data.layout_bounds.x;
	pass->shared_quad_states.push_back(quad_state.Pass());

	if (it->second->layout_info) {
	quad->material = mojo::Material::SURFACE_CONTENT;
	quad->surface_quad_state = mojo::SurfaceQuadState::New();
	quad->surface_quad_state->surface =
	view_data.layout_info->surface_id.Clone();
	} else {
	quad->material = mojo::Material::SOLID_COLOR;
	quad->solid_color_quad_state = mojo::SolidColorQuadState::New();
	quad->solid_color_quad_state->color = mojo::Color::New();
	quad->solid_color_quad_state->color->rgba = 0xffff00ff;
	}

	pass->quads.push_back(quad.Pass());
	}

	frame->passes.push_back(pass.Pass());

	frame_pending_ = true;
	surfaces_->SubmitFrame(
	surface_id_->local, frame.Pass(),
	base::Bind(&TileView::OnFrameSubmitted, base::Unretained(this)));

	// Submit the new layout information.
	mojo::ui::ViewLayoutInfoPtr info = mojo::ui::ViewLayoutInfo::New();
	info->size = size_.Clone();
	info->surface_id = surface_id_->Clone();
	pending_layout_callback_.Run(info.Pass());
	pending_layout_callback_.reset();
	}

	void TileView::OnFrameSubmitted() {
	DCHECK(frame_pending_);

	frame_pending_ = false;
	FinishLayout();
	}

	TileView::ViewData::ViewData(const std::string& url)
	: url(url), layout_pending(false) {}

	TileView::ViewData::~ViewData() {}

	} // namespace examples