services/gfx/compositor/graph/scene_def.cc

// 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 "services/gfx/compositor/graph/scene_def.h"

#include <ostream>

#include "base/bind.h"
#include "base/logging.h"
#include "base/message_loop/message_loop.h"
#include "base/strings/stringprintf.h"
#include "mojo/services/gfx/composition/cpp/formatting.h"
#include "services/gfx/compositor/graph/snapshot.h"
#include "services/gfx/compositor/render/render_image.h"
#include "services/gfx/compositor/render/render_layer.h"

namespace compositor {

namespace {
// TODO(jeffbrown): Determine and document a more appropriate size limit
// for transferred images as part of the image pipe abstraction instead.
const int32_t kMaxTextureWidth = 65536;
const int32_t kMaxTextureHeight = 65536;

void ReleaseMailboxTexture(
    mojo::gfx::composition::MailboxTextureCallbackPtr callback) {
  if (callback)
    callback->OnMailboxTextureReleased();
}
}  // namespace

SceneDef::SceneDef(mojo::gfx::composition::SceneTokenPtr scene_token,
                   const std::string& label)
    : scene_token_(scene_token.Pass()), label_(label) {
  DCHECK(scene_token_);
}

SceneDef::~SceneDef() {}

void SceneDef::EnqueueUpdate(mojo::gfx::composition::SceneUpdatePtr update) {
  DCHECK(update);
  pending_updates_.push_back(update.Pass());
}

void SceneDef::EnqueuePublish(
    mojo::gfx::composition::SceneMetadataPtr metadata) {
  DCHECK(metadata);
  pending_publications_.emplace_back(new Publication(metadata.Pass()));
  pending_updates_.swap(pending_publications_.back()->updates);
}

SceneDef::Disposition SceneDef::Present(
    int64_t presentation_time,
    const SceneResolver& resolver,
    const SceneUnavailableSender& unavailable_sender,
    std::ostream& err) {
  // Walk backwards through the pending publications to find the index
  // just beyond the last one which is due to be presented at or before the
  // presentation time.
  size_t end = pending_publications_.size();
  for (;;) {
    if (!end)
      return Disposition::kUnchanged;
    if (pending_publications_[end - 1]->is_due(presentation_time))
      break;  // found last presentable publication
    end--;
  }

  // Prepare to apply all publications up to this point.
  uint32_t version = pending_publications_[end - 1]->metadata->version;
  if (version_ != version) {
    version_ = version;
    formatted_label_cache_.clear();
  }
  Invalidate();

  // Apply all updates sequentially.
  for (size_t index = 0; index < end; ++index) {
    for (auto& update : pending_publications_[index]->updates) {
      if (!ApplyUpdate(update.Pass(), resolver, unavailable_sender, err))
        return Disposition::kFailed;
    }
  }

  // Dequeue the publications we processed.
  pending_publications_.erase(pending_publications_.begin(),
                              pending_publications_.begin() + end);

  // Ensure the scene is in a valid state.
  if (!Validate(err))
    return Disposition::kFailed;
  return Disposition::kSucceeded;
}

bool SceneDef::ApplyUpdate(mojo::gfx::composition::SceneUpdatePtr update,
                           const SceneResolver& resolver,
                           const SceneUnavailableSender& unavailable_sender,
                           std::ostream& err) {
  DCHECK(update);

  // Update resources.
  if (update->clear_resources) {
    resources_.clear();
  }
  for (auto it = update->resources.begin(); it != update->resources.end();
       ++it) {
    uint32_t resource_id = it.GetKey();
    mojo::gfx::composition::ResourcePtr& resource_decl = it.GetValue();
    if (resource_decl) {
      ResourceDef* resource = CreateResource(resource_id, resource_decl.Pass(),
                                             resolver, unavailable_sender, err);
      if (!resource)
        return false;
      resources_[resource_id].reset(resource);
    } else {
      resources_.erase(resource_id);
    }
  }

  // Update nodes.
  if (update->clear_nodes) {
    nodes_.clear();
  }
  for (auto it = update->nodes.begin(); it != update->nodes.end(); ++it) {
    uint32_t node_id = it.GetKey();
    mojo::gfx::composition::NodePtr& node_decl = it.GetValue();
    if (node_decl) {
      NodeDef* node = CreateNode(node_id, node_decl.Pass(), err);
      if (!node)
        return false;
      nodes_[node_id].reset(node);
    } else {
      nodes_.erase(node_id);
    }
  }
  return true;
}

bool SceneDef::Validate(std::ostream& err) {
  // Validate all nodes.
  // TODO(jeffbrown): Figure out how to do this incrementally if it gets
  // too expensive to process all nodes each time.
  root_node_ = nullptr;
  for (auto& pair : nodes_) {
    uint32_t node_id = pair.first;
    NodeDef* node = pair.second.get();
    if (!node->Validate(this, err))
      return false;
    if (node_id == mojo::gfx::composition::kSceneRootNodeId)
      root_node_ = node;
  }
  return true;
}

bool SceneDef::UnlinkReferencedScene(
    SceneDef* scene,
    const SceneUnavailableSender& unavailable_sender) {
  DCHECK(scene);

  bool changed = false;
  for (auto& pair : resources_) {
    if (pair.second->type() == ResourceDef::Type::kScene) {
      auto scene_resource = static_cast<SceneResourceDef*>(pair.second.get());
      if (scene_resource->referenced_scene() == scene) {
        scene_resource->clear_referenced_scene();
        Invalidate();
        changed = true;
        unavailable_sender.Run(pair.first);
      }
    }
  }
  return changed;
}

bool SceneDef::Snapshot(SnapshotBuilder* snapshot_builder,
                        RenderLayerBuilder* layer_builder) {
  DCHECK(snapshot_builder);
  DCHECK(layer_builder);

  // Detect cycles.
  if (visited_) {
    if (snapshot_builder->block_log()) {
      *snapshot_builder->block_log()
          << "Scene blocked due to recursive cycle: " << FormattedLabel()
          << std::endl;
    }
    return false;
  }

  // Snapshot the contents of the scene.
  visited_ = true;
  bool success = SnapshotInner(snapshot_builder, layer_builder);
  visited_ = false;
  return success;
}

bool SceneDef::SnapshotInner(SnapshotBuilder* snapshot_builder,
                             RenderLayerBuilder* layer_builder) {
  // Note the dependency even if blocked.
  snapshot_builder->AddSceneDependency(this);

  // Ensure we have a root node.
  if (!root_node_) {
    if (snapshot_builder->block_log()) {
      *snapshot_builder->block_log()
          << "Scene blocked due because it has no root node: "
          << FormattedLabel() << std::endl;
    }
    return false;
  }

  // Snapshot and draw the layer.
  std::shared_ptr<RenderLayer> scene_layer = SnapshotLayer(snapshot_builder);
  if (!scene_layer)
    return false;
  layer_builder->DrawLayer(scene_layer);
  return true;
}

std::shared_ptr<RenderLayer> SceneDef::SnapshotLayer(
    SnapshotBuilder* snapshot_builder) {
  if (cached_layer_)
    return cached_layer_;

  RenderLayerBuilder scene_layer_builder;
  scene_layer_builder.PushScene(scene_token_->value, version_);
  if (!root_node_->Snapshot(snapshot_builder, &scene_layer_builder, this))
    return nullptr;
  scene_layer_builder.PopScene();

  // TODO(jeffbrown): Implement caching even when the scene has dependencies.
  // There are some subtleties to be dealt with to ensure that caches
  // are properly invalidated and that we don't accidentally cache layers which
  // bake in decisions which counteract the intended cycle detection and
  // avoidance behavior.  Basically just need better bookkeeping.
  std::shared_ptr<RenderLayer> scene_layer = scene_layer_builder.Build();
  if (!HasSceneResources())
    cached_layer_ = scene_layer;
  return scene_layer;
}

void SceneDef::Invalidate() {
  cached_layer_.reset();
}

bool SceneDef::HasSceneResources() {
  for (auto& pair : resources_) {
    if (pair.second->type() == ResourceDef::Type::kScene)
      return true;
  }
  return false;
}

ResourceDef* SceneDef::CreateResource(
    uint32_t resource_id,
    mojo::gfx::composition::ResourcePtr resource_decl,
    const SceneResolver& resolver,
    const SceneUnavailableSender& unavailable_sender,
    std::ostream& err) {
  DCHECK(resource_decl);

  if (resource_decl->is_scene()) {
    auto& scene_resource_decl = resource_decl->get_scene();
    DCHECK(scene_resource_decl->scene_token);
    SceneDef* referenced_scene =
        resolver.Run(scene_resource_decl->scene_token.get());
    if (!referenced_scene) {
      unavailable_sender.Run(resource_id);
    }
    return new SceneResourceDef(referenced_scene);
  }

  if (resource_decl->is_mailbox_texture()) {
    auto& mailbox_texture_resource_decl = resource_decl->get_mailbox_texture();
    DCHECK(mailbox_texture_resource_decl->mailbox_name.size() ==
           GL_MAILBOX_SIZE_CHROMIUM);
    DCHECK(mailbox_texture_resource_decl->size);
    int32_t width = mailbox_texture_resource_decl->size->width;
    int32_t height = mailbox_texture_resource_decl->size->height;
    if (width < 1 || width > kMaxTextureWidth || height < 1 ||
        height > kMaxTextureHeight) {
      err << "MailboxTexture resource has invalid size: "
          << "resource_id=" << resource_id << ", width=" << width
          << ", height=" << height;
      return nullptr;
    }
    std::shared_ptr<RenderImage> image = RenderImage::CreateFromMailboxTexture(
        reinterpret_cast<GLbyte*>(
            mailbox_texture_resource_decl->mailbox_name.data()),
        mailbox_texture_resource_decl->sync_point, width, height,
        base::MessageLoop::current()->task_runner(),
        base::Bind(
            &ReleaseMailboxTexture,
            base::Passed(mailbox_texture_resource_decl->callback.Pass())));
    if (!image) {
      err << "Could not create MailboxTexture";
      return nullptr;
    }
    return new ImageResourceDef(image);
  }

  err << "Unsupported resource type: resource_id=" << resource_id;
  return nullptr;
}

NodeDef* SceneDef::CreateNode(uint32_t node_id,
                              mojo::gfx::composition::NodePtr node_decl,
                              std::ostream& err) {
  DCHECK(node_decl);

  NodeOp* op = nullptr;
  if (node_decl->op) {
    op = CreateNodeOp(node_id, node_decl->op.Pass(), err);
    if (!op)
      return nullptr;
  }

  return new NodeDef(node_id, node_decl->content_transform.Pass(),
                     node_decl->content_clip.Pass(), node_decl->hit_id,
                     node_decl->combinator, node_decl->child_node_ids.storage(),
                     op);
}

NodeOp* SceneDef::CreateNodeOp(uint32_t node_id,
                               mojo::gfx::composition::NodeOpPtr node_op_decl,
                               std::ostream& err) {
  DCHECK(node_op_decl);

  if (node_op_decl->is_rect()) {
    auto& rect_node_op_decl = node_op_decl->get_rect();
    DCHECK(rect_node_op_decl->content_rect);
    DCHECK(rect_node_op_decl->color);
    return new RectNodeOp(*rect_node_op_decl->content_rect,
                          *rect_node_op_decl->color);
  }

  if (node_op_decl->is_image()) {
    auto& image_node_op_decl = node_op_decl->get_image();
    DCHECK(image_node_op_decl->content_rect);
    return new ImageNodeOp(*image_node_op_decl->content_rect,
                           image_node_op_decl->image_rect.Pass(),
                           image_node_op_decl->image_resource_id,
                           image_node_op_decl->blend.Pass());
  }

  if (node_op_decl->is_scene()) {
    auto& scene_node_op_decl = node_op_decl->get_scene();
    return new SceneNodeOp(scene_node_op_decl->scene_resource_id,
                           scene_node_op_decl->scene_version);
  }

  if (node_op_decl->is_layer()) {
    auto& layer_node_op_decl = node_op_decl->get_layer();
    DCHECK(layer_node_op_decl->layer_size);
    return new LayerNodeOp(*layer_node_op_decl->layer_size,
                           layer_node_op_decl->blend.Pass());
  }

  err << "Unsupported node op type: node_id=" << node_id
      << ", node_op=" << node_op_decl;
  return nullptr;
}

NodeDef* SceneDef::FindNode(uint32_t node_id) {
  auto it = nodes_.find(node_id);
  return it != nodes_.end() ? it->second.get() : nullptr;
}

ResourceDef* SceneDef::FindResource(uint32_t resource_id,
                                    ResourceDef::Type resource_type) {
  auto it = resources_.find(resource_id);
  return it != resources_.end() && it->second->type() == resource_type
             ? it->second.get()
             : nullptr;
}

std::string SceneDef::FormattedLabel() {
  if (formatted_label_cache_.empty()) {
    formatted_label_cache_ =
        label_.empty()
            ? base::StringPrintf("<%d/%d>", scene_token_->value, version_)
            : base::StringPrintf("<%d:%s/%d>", scene_token_->value,
                                 label_.c_str(), version_);
  }
  return formatted_label_cache_;
}

SceneDef::Publication::Publication(
    mojo::gfx::composition::SceneMetadataPtr metadata)
    : metadata(metadata.Pass()) {
  DCHECK(this->metadata);
}

SceneDef::Publication::~Publication() {}

}  // namespace compositor