resourcehandler.cc

Go to the documentation of this file.

#if !ION_PRODUCTION

#include "ion/remote/resourcehandler.h"

#include <sstream>
#include <string>
#include <vector>

#include "ion/base/allocator.h"
#include "ion/base/invalid.h"
#include "ion/base/stringutils.h"
#include "ion/base/zipassetmanager.h"
#include "ion/base/zipassetmanagermacros.h"
#include "ion/gfx/image.h"
#include "ion/gfx/resourcemanager.h"
#include "ion/gfx/tracinghelper.h"
#include "ion/gfxutils/resourcecallback.h"
#include "ion/image/conversionutils.h"
#include "ion/image/renderutils.h"

ION_REGISTER_ASSETS(IonRemoteResourcesRoot);

namespace ion {
namespace remote {

namespace {

using gfx::AttributeArray;
using gfx::BufferObject;
using gfx::CubeMapTexture;
using gfx::CubeMapTexturePtr;
using gfx::FramebufferObject;
using gfx::Image;
using gfx::ImagePtr;
using gfx::Renderer;
using gfx::RendererPtr;
using gfx::ResourceManager;
using gfx::Sampler;
using gfx::Shader;
using gfx::ShaderProgram;
using gfx::TextureBase;
using gfx::Texture;
using gfx::TexturePtr;
using gfxutils::ArrayCallback;
using gfxutils::BufferCallback;
using gfxutils::FramebufferCallback;
using gfxutils::PlatformCallback;
using gfxutils::ProgramCallback;
using gfxutils::SamplerCallback;
using gfxutils::ShaderCallback;
using gfxutils::TextureCallback;
using gfxutils::TextureImageCallback;
using std::bind;
using std::placeholders::_1;

typedef ResourceManager::ArrayInfo ArrayInfo;
typedef ResourceManager::BufferInfo BufferInfo;
typedef ResourceManager::FramebufferInfo FramebufferInfo;
typedef ResourceManager::RenderbufferInfo RenderbufferInfo;
typedef ResourceManager::PlatformInfo PlatformInfo;
typedef ResourceManager::ProgramInfo ProgramInfo;
typedef ResourceManager::SamplerInfo SamplerInfo;
typedef ResourceManager::ShaderInfo ShaderInfo;
typedef ResourceManager::TextureImageInfo TextureImageInfo;
typedef ResourceManager::TextureInfo TextureInfo;




class Indent {
 public:
  explicit Indent(size_t spaces) : indent_(spaces, ' '), spaces_(spaces) {}

  friend std::ostream& operator<<(std::ostream& out, const Indent& indent) {
    out << indent.indent_;
    return out;
  }

  friend const Indent operator+(const Indent& indent, size_t spaces) {
    return Indent(indent.spaces_ + spaces);
  }

 private:
  const std::string indent_;
  const size_t spaces_;
};

static const std::string EscapeJson(const std::string& str) {
  std::string ret = base::ReplaceString(str, "\\", "\\\\");
  ret = base::ReplaceString(ret, "\"", "\\\"");
  ret = base::EscapeNewlines(ret);
  return ret;
}




class RenderTextureCallback : public TextureImageCallback {
 public:
  typedef base::ReferentPtr<RenderTextureCallback>::Type RefPtr;

  RenderTextureCallback(const RendererPtr& renderer, bool do_wait)
      : TextureImageCallback(do_wait),
        renderer_(renderer) {}

  void Callback(const std::vector<TextureImageInfo>& data);

 private:
  ~RenderTextureCallback() override {}

  void RenderTextureImage(const RendererPtr& renderer, TextureImageInfo* info);
  void RenderCubeMapTextureImages(const RendererPtr& renderer,
                                  TextureImageInfo* info);

  const RendererPtr& renderer_;
};

void RenderTextureCallback::Callback(
    const std::vector<TextureImageInfo>& data) {
  RefPtr holder(this);

  const bool flag_was_set =
      renderer_->GetFlags().test(Renderer::kProcessInfoRequests);
  renderer_->ClearFlag(Renderer::kProcessInfoRequests);

  std::vector<TextureImageInfo> new_data = data;
  const size_t data_count = new_data.size();
  for (size_t i = 0; i < data_count; ++i) {
    TextureImageInfo* info = &new_data[i];
    if (info->texture.Get()) {
      if (info->texture->GetTextureType() == TextureBase::kTexture)
        RenderTextureImage(renderer_, info);
      else
        RenderCubeMapTextureImages(renderer_, info);
    }
  }

  if (flag_was_set)
    renderer_->SetFlag(Renderer::kProcessInfoRequests);

  TextureImageCallback::Callback(new_data);
}

void RenderTextureCallback::RenderTextureImage(
    const RendererPtr& renderer, TextureImageInfo* info) {
  DCHECK(info);
  DCHECK_EQ(info->texture->GetTextureType(), TextureBase::kTexture);
  DCHECK_EQ(info->images.size(), 1U);

  const ImagePtr& input_image = info->images[0];
  if (input_image.Get()) {
    TexturePtr tex(static_cast<Texture*>(info->texture.Get()));
    const base::AllocatorPtr& sta =
        tex->GetAllocator()->GetAllocatorForLifetime(base::kShortTerm);
    ImagePtr output_image = image::RenderTextureImage(
        tex, input_image->GetWidth(), input_image->GetHeight(), renderer, sta);
    if (output_image.Get())
      info->images[0] = output_image;
  }
}

void RenderTextureCallback::RenderCubeMapTextureImages(
    const RendererPtr& renderer, TextureImageInfo* info) {
  DCHECK(info);
  DCHECK_EQ(info->texture->GetTextureType(), TextureBase::kCubeMapTexture);
  DCHECK_EQ(info->images.size(), 6U);

  CubeMapTexturePtr tex(static_cast<CubeMapTexture*>(info->texture.Get()));
  const base::AllocatorPtr& sta =
      tex->GetAllocator()->GetAllocatorForLifetime(base::kShortTerm);
  for (int i = 0; i < 6; ++i) {
    const ImagePtr& input_image = info->images[i];
    const CubeMapTexture::CubeFace face =
        static_cast<CubeMapTexture::CubeFace>(i);
    ImagePtr output_image =
        image::RenderCubeMapTextureFaceImage(
            tex, face, input_image->GetWidth(), input_image->GetHeight(),
            renderer, sta);
    if (output_image.Get())
      info->images[i] = output_image;
  }
}




static const std::string ConvertAttachmentToJson(
    const Indent& indent,
    const FramebufferInfo::Attachment& info,
    const RenderbufferInfo& rb_info) {
  gfx::TracingHelper helper;
  std::ostringstream str;
  const Indent indent2 = indent + 2;

  str << indent << "\"type\": \""
      << (info.type ? helper.ToString("GLenum", info.type) : "GL_NONE")
      << "\",\n";
  str << indent;
  if (info.type == GL_TEXTURE)
    str << "\"texture_glid\": " << info.value << ",\n";
  else
    str << "\"value\": " << info.value << ",\n";
  str << indent << "\"mipmap_level\": " << info.level << ",\n";
  str << indent << "\"cube_face\": \""
      << (info.cube_face ? helper.ToString("GLenum", info.cube_face)
                         : "GL_NONE") << "\",\n";
  str << indent << "\"renderbuffer\": {\n";
  str << indent2 << "\"object_id\": " << rb_info.id << ",\n";
  str << indent2 << "\"label\": " << "\"" << rb_info.label << "\",\n";
  str << indent2 << "\"width\": " << rb_info.width << ",\n";
  str << indent2 << "\"height\": " << rb_info.height << ",\n";
  str << indent2 << "\"internal_format\": \""
      << helper.ToString("GLenum", rb_info.internal_format) << "\",\n";
  str << indent2 << "\"red_size\": " << rb_info.red_size << ",\n";
  str << indent2 << "\"green_size\": " << rb_info.green_size << ",\n";
  str << indent2 << "\"blue_size\": " << rb_info.blue_size << ",\n";
  str << indent2 << "\"alpha_size\": " << rb_info.alpha_size << ",\n";
  str << indent2 << "\"depth_size\": " << rb_info.depth_size << ",\n";
  str << indent2 << "\"stencil_size\": " << rb_info.stencil_size << "\n";
  str << indent << "}\n";
  return str.str();
}

const std::string ConvertEnumVectorToJson(const std::vector<GLenum>& vec) {
  gfx::TracingHelper helper;
  std::ostringstream str;
  const size_t count = vec.size();
  for (size_t i = 0; i < count; ++i) {
    if (i)
      str << ", ";
    str << helper.ToString("GLenum", vec[i]);
  }

  return str.str();
}

template <typename T>
static const std::string ConvertShaderInputToJson(const Indent& indent,
                                                  const T& input) {
  gfx::TracingHelper helper;
  std::ostringstream str;
  str << indent << "\"name\": \"" << input.name << "\",\n";
  str << indent << "\"index\": " << input.index << ",\n";
  str << indent << "\"size\": " << input.size << ",\n";
  str << indent << "\"type\": \"" << helper.ToString("GLenum", input.type)
      << "\"\n";
  return str.str();
}

static const std::string ConvertProgramAttributesToJson(
    const Indent& indent, const std::vector<ProgramInfo::Attribute>& attrs) {
  gfx::TracingHelper helper;
  std::ostringstream str;
  const size_t count = attrs.size();
  for (size_t i = 0; i < count; ++i) {
    str << indent << "{\n";
    str << ConvertShaderInputToJson(indent + 2, attrs[i]);
    str << indent << "}" << (i < count - 1U ? "," : "") << "\n";
  }
  return str.str();
}

template <typename T>
static void StreamProgramUniform(const ProgramInfo::Uniform& uniform,
                                 std::ostream& str) {  // NOLINT
  str << "\"";
  if (uniform.size > 1) {
    str << "[";
    for (GLint i = 0; i < uniform.size; i++) {
      if (i)
        str << ", ";
      str << uniform.value.GetValueAt<T>(i);
    }
    str << "]";
  } else {
    str << uniform.value.Get<T>();
  }
  str << "\"";
}

template <typename T>
static void StreamProgramUniformVector(const ProgramInfo::Uniform& uniform,
                                       std::ostream& str) {  // NOLINT
  str << "\"";
  if (uniform.size > 1) {
    str << "[";
    for (GLint i = 0; i < uniform.size; i++) {
      if (i)
        str << ", ";
      uniform.value.GetValueAt<T>(i).Print(str, 'V');
    }
    str << "]";
  } else {
    uniform.value.Get<T>().Print(str, 'V');
  }
  str << "\"";
}

static const std::string ConvertProgramUniformsToJson(
    const Indent& indent, const std::vector<ProgramInfo::Uniform>& uniforms) {
  gfx::TracingHelper helper;
  std::ostringstream str;
  const Indent indent2 = indent + 2;

  const size_t count = uniforms.size();
  for (size_t i = 0; i < count; ++i) {
    const ProgramInfo::Uniform& u = uniforms[i];
    str << indent << "{\n";
    str << indent2 << "\"value\": ";
    switch (u.type) {
      case GL_FLOAT:
        StreamProgramUniform<float>(u, str);
        break;
      case GL_FLOAT_VEC2:
        StreamProgramUniformVector<math::VectorBase2f>(u, str);
        break;
      case GL_FLOAT_VEC3:
        StreamProgramUniformVector<math::VectorBase3f>(u, str);
        break;
      case GL_FLOAT_VEC4:
        StreamProgramUniformVector<math::VectorBase4f>(u, str);
        break;
      case GL_INT:
      case GL_INT_SAMPLER_1D:
      case GL_INT_SAMPLER_1D_ARRAY:
      case GL_INT_SAMPLER_2D:
      case GL_INT_SAMPLER_2D_ARRAY:
      case GL_INT_SAMPLER_3D:
      case GL_INT_SAMPLER_CUBE:
      case GL_INT_SAMPLER_CUBE_MAP_ARRAY:
      case GL_SAMPLER_1D:
      case GL_SAMPLER_1D_ARRAY:
      case GL_SAMPLER_1D_ARRAY_SHADOW:
      case GL_SAMPLER_1D_SHADOW:
      case GL_SAMPLER_2D:
      case GL_SAMPLER_2D_ARRAY:
      case GL_SAMPLER_2D_ARRAY_SHADOW:
      case GL_SAMPLER_2D_MULTISAMPLE:
      case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
      case GL_SAMPLER_2D_SHADOW:
      case GL_SAMPLER_3D:
      case GL_SAMPLER_CUBE:
      case GL_SAMPLER_CUBE_MAP_ARRAY:
      case GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW:
      case GL_SAMPLER_CUBE_SHADOW:
      case GL_SAMPLER_EXTERNAL_OES:
      case GL_UNSIGNED_INT_SAMPLER_1D:
      case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY:
      case GL_UNSIGNED_INT_SAMPLER_2D:
      case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
      case GL_UNSIGNED_INT_SAMPLER_3D:
      case GL_UNSIGNED_INT_SAMPLER_CUBE:
      case GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY:
        StreamProgramUniform<int>(u, str);
        break;
      case GL_INT_VEC2:
        StreamProgramUniformVector<math::VectorBase2i>(u, str);
        break;
      case GL_INT_VEC3:
        StreamProgramUniformVector<math::VectorBase3i>(u, str);
        break;
      case GL_INT_VEC4:
        StreamProgramUniformVector<math::VectorBase4i>(u, str);
        break;
      case GL_UNSIGNED_INT:
        StreamProgramUniform<uint32>(u, str);
        break;
      case GL_UNSIGNED_INT_VEC2:
        StreamProgramUniformVector<math::VectorBase2ui>(u, str);
        break;
      case GL_UNSIGNED_INT_VEC3:
        StreamProgramUniformVector<math::VectorBase3ui>(u, str);
        break;
      case GL_UNSIGNED_INT_VEC4:
        StreamProgramUniformVector<math::VectorBase4ui>(u, str);
        break;
      case GL_FLOAT_MAT2:
        StreamProgramUniform<math::Matrix2f>(u, str);
        break;
      case GL_FLOAT_MAT3:
        StreamProgramUniform<math::Matrix3f>(u, str);
        break;
      case GL_FLOAT_MAT4:
        StreamProgramUniform<math::Matrix4f>(u, str);
        break;
#if !defined(ION_COVERAGE)  // COV_NF_START
      default:
        break;
#endif  // COV_NF_END
    }
    str << ",\n";
    str << ConvertShaderInputToJson(indent + 2, u);
    str << indent << "}" << (i < count - 1U ? "," : "") << "\n";
  }
  return str.str();
}

template <typename InfoType>
static const std::string ConvertInfoToJson(const Indent& indent,
                                           const InfoType& info) {
  CHECK(false) << "Unspecialized ConvertInfoToJson() called.";
  return std::string();
}

template <>
const std::string ConvertInfoToJson(const Indent& indent,
                                    const PlatformInfo& info) {
  std::ostringstream str;
  const Indent indent2 = indent + 2;
  const Indent indent4 = indent + 4;

  str << indent << "\"renderer\": \"" << info.renderer << "\",\n";
  str << indent << "\"vendor\": \"" << info.vendor << "\",\n";
  str << indent << "\"version_string\": \"" << info.version_string << "\",\n";
  str << indent << "\"gl_version\": " << info.major_version << "."
      << info.minor_version << ",\n";
  str << indent << "\"glsl_version\": " << info.glsl_version << ",\n";
  str << indent << "\"aliased_line_width_range\": \""
      << info.aliased_line_width_range[0] << " - "
      << info.aliased_line_width_range[1] << "\",\n";
  str << indent << "\"aliased_point_size_range\": \""
      << info.aliased_point_size_range[0] << " - "
      << info.aliased_point_size_range[1] << "\",\n";
  str << indent << "\"max_color_attachments\": "
      << info.max_color_attachments << ",\n";
  str << indent << "\"max_combined_texture_image_units\": "
      << info.max_combined_texture_image_units << ",\n";
  str << indent << "\"max_cube_map_texture_size\": "
      << info.max_cube_map_texture_size << ",\n";
  str << indent << "\"max_draw_buffers\": "
      << info.max_draw_buffers << ",\n";
  str << indent << "\"max_fragment_uniform_vectors\": "
      << info.max_fragment_uniform_vectors << ",\n";
  str << indent << "\"max_renderbuffer_size\": " << info.max_renderbuffer_size
      << ",\n";
  str << indent << "\"max_texture_image_units\": "
      << info.max_texture_image_units << ",\n";
  str << indent << "\"max_texture_size\": " << info.max_texture_size << ",\n";
  str << indent << "\"max_transform_feedback_buffers\": "
      << info.max_transform_feedback_buffers << ",\n";
  str << indent << "\"max_transform_feedback_interleaved_components\": "
      << info.max_transform_feedback_interleaved_components << ",\n";
  str << indent << "\"max_transform_feedback_separate_attribs\": "
      << info.max_transform_feedback_separate_attribs << ",\n";
  str << indent << "\"max_transform_feedback_separate_components\": "
      << info.max_transform_feedback_separate_components << ",\n";
  str << indent << "\"max_varying_vectors\": " << info.max_varying_vectors
      << ",\n";
  str << indent << "\"max_vertex_attribs\": " << info.max_vertex_attribs
      << ",\n";
  str << indent << "\"max_vertex_texture_image_units\": "
      << info.max_vertex_texture_image_units << ",\n";
  str << indent << "\"max_vertex_uniform_vectors\": "
      << info.max_vertex_uniform_vectors << ",\n";
  str << indent << "\"max_viewport_dims\": \"" << info.max_viewport_dims[0]
      << " x " << info.max_viewport_dims[1] << "\",\n";
  str << indent << "\"transform_feedback_varying_max_length\": "
      << info.transform_feedback_varying_max_length << ",\n";
  str << indent << "\"compressed_texture_formats\": \""
      << ConvertEnumVectorToJson(info.compressed_texture_formats) << "\",\n";
  str << indent << "\"shader_binary_formats\": \""
      << ConvertEnumVectorToJson(info.shader_binary_formats) << "\",\n";
  str << indent << "\"extensions\": \"" << info.extensions << "\"\n";

  return str.str();
}


template <>
const std::string ConvertInfoToJson(const Indent& indent,
                                    const ArrayInfo& info) {
  gfx::TracingHelper helper;
  std::ostringstream str;
  const Indent indent2 = indent + 2;
  const Indent indent4 = indent + 4;

  str << indent << "\"object_id\": " << info.id << ",\n";
  str << indent << "\"label\": " << "\"" << info.label << "\",\n";
  str << indent << "\"vertex_count\": " << info.vertex_count << ",\n";
  str << indent << "\"attributes\": [\n";
  const size_t count = info.attributes.size();
  for (size_t i = 0; i < count; ++i) {
    str << indent2 << "{\n";
    str << indent4 << "\"buffer_glid\": " << info.attributes[i].buffer << ",\n";
    str << indent4 << "\"enabled\": \""
        << helper.ToString("GLboolean", info.attributes[i].enabled) << "\",\n";
    str << indent4 << "\"size\": " << info.attributes[i].size << ",\n";
    str << indent4 << "\"stride\": " << info.attributes[i].stride << ",\n";
    str << indent4 << "\"type\": \""
        << helper.ToString("GLenum", info.attributes[i].type) << "\",\n";
    str << indent4 << "\"normalized\": \""
        << helper.ToString("GLboolean", info.attributes[i].normalized)
        << "\",\n";
    str << indent4 << "\"pointer_or_offset\": \""
        << helper.ToString("GLvoid*", info.attributes[i].pointer) << "\",\n";
    str << indent4 << "\"value\": \"" << info.attributes[i].value << "\"\n";
    str << indent2 << "}" << (i < count - 1U ? "," : "") << "\n";
  }
  str << indent << "]\n";

  return str.str();
}

template <>
const std::string ConvertInfoToJson(const Indent& indent,
                                    const BufferInfo& info) {
  gfx::TracingHelper helper;
  std::ostringstream str;
  str << indent << "\"object_id\": " << info.id << ",\n";
  str << indent << "\"label\": " << "\"" << info.label << "\",\n";
  str << indent << "\"size\": " << info.size << ",\n";
  str << indent << "\"usage\": \"" << helper.ToString("GLenum", info.usage)
      << "\",\n";
  str << indent << "\"mapped_pointer\": \""
      << helper.ToString("GLvoid*", info.mapped_data) << "\",\n";
  str << indent << "\"target\": \"" << helper.ToString("GLenum", info.target)
      << "\"\n";
  return str.str();
}

template <>
const std::string ConvertInfoToJson(const Indent& indent,
                                    const FramebufferInfo& info) {
  std::ostringstream str;
  const Indent indent2 = indent + 2;
  str << indent << "\"object_id\": " << info.id << ",\n";
  str << indent << "\"label\": " << "\"" << info.label << "\",\n";
  str << indent << "\"attachment_color0\": {\n";
  str << ConvertAttachmentToJson(
             indent2, info.color0, info.color0_renderbuffer);
  str << indent << "},\n";
  str << indent << "\"attachment_depth\": {\n";
  str << ConvertAttachmentToJson(indent2, info.depth, info.depth_renderbuffer);
  str << indent << "},\n";
  str << indent << "\"attachment_stencil\": {\n";
  str << ConvertAttachmentToJson(
             indent2, info.stencil, info.stencil_renderbuffer);
  str << indent << "}\n";
  return str.str();
}

template <>
const std::string ConvertInfoToJson(const Indent& indent,
                                    const ProgramInfo& info) {
  gfx::TracingHelper helper;
  std::ostringstream str;
  const Indent indent2 = indent + 2;
  str << indent << "\"object_id\": " << info.id << ",\n";
  str << indent << "\"label\": " << "\"" << info.label << "\",\n";
  str << indent << "\"vertex_shader_glid\": " << info.vertex_shader << ",\n";
  str << indent << "\"fragment_shader_glid\": " << info.fragment_shader
      << ",\n";
  str << indent << "\"delete_status\": \""
      << helper.ToString("GLboolean", info.delete_status) << "\",\n";
  str << indent << "\"link_status\": \""
      << helper.ToString("GLboolean", info.link_status) << "\",\n";
  str << indent << "\"validate_status\": \""
      << helper.ToString("GLboolean", info.validate_status) << "\",\n";
  str << indent << "\"attributes\": [\n";
  str << ConvertProgramAttributesToJson(indent2, info.attributes);
  str << indent << "],\n";
  str << indent << "\"uniforms\": [\n";
  str << ConvertProgramUniformsToJson(indent2, info.uniforms);
  str << indent << "],\n";
  str << indent << "\"info_log\": \"" << EscapeJson(info.info_log)
      << "\"\n";
  return str.str();
}

template <>
const std::string ConvertInfoToJson(const Indent& indent,
                                    const SamplerInfo& info) {
  gfx::TracingHelper helper;
  std::ostringstream str;
  str << indent << "\"object_id\": " << info.id << ",\n";
  str << indent << "\"label\": " << "\"" << info.label << "\",\n";
  str << indent << "\"compare_function\": \""
      << helper.ToString("GLtextureenum", info.compare_func) << "\",\n";
  str << indent << "\"compare_mode\": \""
      << helper.ToString("GLtextureenum", info.compare_mode) << "\",\n";
  str << indent << "\"max_anisotropy\": " << info.max_anisotropy << ",\n";
  str << indent << "\"min_lod\": " << info.min_lod << ",\n";
  str << indent << "\"max_lod\": " << info.max_lod << ",\n";
  str << indent << "\"min_filter\": \""
      << helper.ToString("GLenum", info.min_filter) << "\",\n";
  str << indent << "\"mag_filter\": \""
      << helper.ToString("GLenum", info.mag_filter) << "\",\n";
  str << indent << "\"wrap_r\": \"" << helper.ToString("GLenum", info.wrap_r)
      << "\",\n";
  str << indent << "\"wrap_s\": \"" << helper.ToString("GLenum", info.wrap_s)
      << "\",\n";
  str << indent << "\"wrap_t\": \"" << helper.ToString("GLenum", info.wrap_t)
      << "\"\n";
  return str.str();
}

template <>
const std::string ConvertInfoToJson(const Indent& indent,
                                    const ShaderInfo& info) {
  gfx::TracingHelper helper;
  std::ostringstream str;
  str << indent << "\"object_id\": " << info.id << ",\n";
  str << indent << "\"label\": " << "\"" << info.label << "\",\n";
  str << indent << "\"type\": \"" << helper.ToString("GLenum", info.type)
      << "\",\n";
  str << indent << "\"delete_status\": \""
      << helper.ToString("GLboolean", info.delete_status) << "\",\n";
  str << indent << "\"compile_status\": \""
      << helper.ToString("GLboolean", info.compile_status) << "\",\n";
  str << indent << "\"source\": \""
      << base::MimeBase64EncodeString("<pre><code>" + info.source +
                                      "</code></pre>") << "\",\n";
  str << indent << "\"info_log\": \"" << EscapeJson(info.info_log)
      << "\"\n";
  return str.str();
}

template <>
const std::string ConvertInfoToJson(const Indent& indent,
                                    const TextureInfo& info) {
  gfx::TracingHelper helper;
  std::ostringstream str;
  str << indent << "\"object_id\": " << info.id << ",\n";
  str << indent << "\"label\": " << "\"" << info.label << "\",\n";
  str << indent << "\"width\": " << info.width << ",\n";
  str << indent << "\"height\": " << info.height<< ",\n";
  str << indent << "\"format\": \"" << Image::GetFormatString(info.format)
      << "\",\n";
  str << indent << "\"sampler_glid\": " << info.sampler << ",\n";
  str << indent << "\"base_level\": " << info.base_level << ",\n";
  str << indent << "\"max_level\": " << info.max_level << ",\n";
  str << indent << "\"compare_function\": \""
      << helper.ToString("GLtextureenum", info.compare_func) << "\",\n";
  str << indent << "\"compare_mode\": \""
      << helper.ToString("GLtextureenum", info.compare_mode) << "\",\n";
  str << indent << "\"max_anisotropy\": " << info.max_anisotropy << ",\n";
  str << indent << "\"min_lod\": " << info.min_lod << ",\n";
  str << indent << "\"max_lod\": " << info.max_lod << ",\n";
  str << indent << "\"min_filter\": \""
      << helper.ToString("GLenum", info.min_filter) << "\",\n";
  str << indent << "\"mag_filter\": \""
      << helper.ToString("GLenum", info.mag_filter) << "\",\n";
  str << indent << "\"swizzle_red\": \""
      << helper.ToString("GLtextureenum", info.swizzle_r) << "\",\n";
  str << indent << "\"swizzle_green\": \""
      << helper.ToString("GLtextureenum", info.swizzle_g) << "\",\n";
  str << indent << "\"swizzle_blue\": \""
      << helper.ToString("GLtextureenum", info.swizzle_b) << "\",\n";
  str << indent << "\"swizzle_alpha\": \""
      << helper.ToString("GLtextureenum", info.swizzle_a) << "\",\n";
  str << indent << "\"wrap_r\": \"" << helper.ToString("GLenum", info.wrap_r)
      << "\",\n";
  str << indent << "\"wrap_s\": \"" << helper.ToString("GLenum", info.wrap_s)
      << "\",\n";
  str << indent << "\"wrap_t\": \"" << helper.ToString("GLenum", info.wrap_t)
      << "\",\n";
  str << indent << "\"target\": \"" << helper.ToString("GLenum", info.target)
      << "\",\n";
  str << indent << "\"last_image_unit\": \""
      << helper.ToString("GLenum", info.unit) << "\"\n";
  return str.str();
}

template <typename ResourceType, typename InfoType>
void RequestInfo(
    ResourceManager* manager,
    const typename gfxutils::ResourceCallback<InfoType>::RefPtr& callback) {
  manager->RequestAllResourceInfos<ResourceType, InfoType>(std::bind(
      &gfxutils::ResourceCallback<InfoType>::Callback, callback.Get(), _1));
}

template <>
void RequestInfo<PlatformInfo, PlatformInfo>(
    ResourceManager* manager,
    const gfxutils::ResourceCallback<PlatformInfo>::RefPtr& callback) {
  manager->RequestPlatformInfo(std::bind(
      &gfxutils::ResourceCallback<PlatformInfo>::Callback, callback.Get(), _1));
}

template <typename ResourceType, typename InfoType>
const std::string BuildJsonStruct(const RendererPtr& renderer,
                                  const std::string& name, const Indent& indent,
                                  const bool wait_for_completion) {
  ResourceManager* manager = renderer->GetResourceManager();
  typedef gfxutils::ResourceCallback<InfoType> Callback;
  typename Callback::RefPtr callback(new Callback(wait_for_completion));
  RequestInfo<ResourceType, InfoType>(manager, callback);

  if (!wait_for_completion)
    renderer->ProcessResourceInfoRequests();

  std::vector<InfoType> infos;
  callback->WaitForCompletion(&infos);
  std::ostringstream str;

  const Indent indent2 = indent + 2;
  const Indent indent4 = indent + 4;

  str << indent << "\"" << name << "\": [\n";
  const size_t count = infos.size();
  for (size_t i = 0; i < count; ++i) {
    str << indent2 << "{\n";
    str << ConvertInfoToJson<InfoType>(indent4, infos[i]);
    str << indent2 << "}" << (i < count - 1U ? "," : "") << "\n";
  }

  str << indent << "]";
  return str.str();
}

static const std::string GetResourceList(const RendererPtr& renderer,
                                         const HttpServer::QueryMap& args) {
  const bool wait_for_completion = args.find("nonblocking") == args.end();
  HttpServer::QueryMap::const_iterator it = args.find("types");

  std::ostringstream str;
  if (it != args.end()) {
    str << "{\n";
    const Indent indent(2);
    const std::vector<std::string> types = base::SplitString(it->second, ",");
    const size_t count = types.size();
    for (size_t i = 0; i < count; ++i) {
      if (types[i] == "platform") {
        str << BuildJsonStruct<PlatformInfo, PlatformInfo>(
                   renderer, "platform", indent, wait_for_completion);
      } else if (types[i] == "buffers") {
        str << BuildJsonStruct<BufferObject, BufferInfo>(
                   renderer, "buffers", indent, wait_for_completion);
      } else if (types[i] == "framebuffers") {
        str << BuildJsonStruct<FramebufferObject, FramebufferInfo>(
                   renderer, "framebuffers", indent, wait_for_completion);
      } else if (types[i] == "programs") {
        str << BuildJsonStruct<ShaderProgram, ProgramInfo>(
                   renderer, "programs", indent, wait_for_completion);
      } else if (types[i] == "samplers") {
        str << BuildJsonStruct<Sampler, SamplerInfo>(
                   renderer, "samplers", indent, wait_for_completion);
      } else if (types[i] == "shaders") {
        str << BuildJsonStruct<Shader, ShaderInfo>(renderer, "shaders", indent,
                                                   wait_for_completion);
      } else if (types[i] == "textures") {
        str << BuildJsonStruct<TextureBase, TextureInfo>(
                   renderer, "textures", indent, wait_for_completion);
      } else if (types[i] == "vertex_arrays") {
        str << BuildJsonStruct<AttributeArray, ArrayInfo>(
                   renderer, "vertex_arrays", indent, wait_for_completion);
      } else {
        continue;
      }

      if (i < count - 1)
        str << ",\n";
      else
        str << "\n";
    }
    str << "}\n";
  }
  return str.str();
}

static const std::string GetBufferData(const RendererPtr& renderer,
                                       const HttpServer::QueryMap& args) {
  return std::string();
}

static void WriteFaceIntoCubeMap(uint32 x_offset,
                                 uint32 y_offset,
                                 const ImagePtr& face,
                                 const ImagePtr& cubemap) {
  const uint32 x_offset_bytes = x_offset * 3;
  const uint32 face_height = face->GetHeight();
  const uint32 face_row_bytes = face->GetWidth() * 3;
  const uint32 cube_row_bytes = cubemap->GetWidth() * 3;
  const uint8* in = face->GetData()->GetData<uint8>();
  uint8* out = cubemap->GetData()->GetMutableData<uint8>();
  DCHECK(in);
  DCHECK(out);
  for (uint32 row = 0; row < face_height; ++row) {
    const uint32 y = face_height - row - 1;
    memcpy(&out[(y_offset + y) * cube_row_bytes + x_offset_bytes],
           &in[y * face_row_bytes], face_row_bytes);
  }
}

static const std::string GetTextureData(const RendererPtr& renderer,
                                        const HttpServer::QueryMap& args,
                                        bool wait_for_completion) {
  std::string data;
  HttpServer::QueryMap::const_iterator id_it = args.find("id");
  if (id_it != args.end()) {
    if (GLuint id = static_cast<GLuint>(base::StringToInt32(id_it->second))) {
      ResourceManager* manager = renderer->GetResourceManager();
      RenderTextureCallback::RefPtr callback(
          new RenderTextureCallback(renderer, wait_for_completion));
      manager->RequestTextureImage(
          id, std::bind(&RenderTextureCallback::Callback, callback.Get(), _1));
      if (!wait_for_completion)
        renderer->ProcessResourceInfoRequests();

      std::vector<TextureImageInfo> infos;
      callback->WaitForCompletion(&infos);

      if (infos.size() && infos[0].images.size()) {
        if (infos[0].images.size() == 1U) {
          const std::vector<uint8> png_data = image::ConvertToExternalImageData(
              infos[0].images[0], image::kPng, true);
          data = base::MimeBase64EncodeString(
              std::string(png_data.begin(), png_data.end()));
        } else {
          DCHECK_EQ(6U, infos[0].images.size());
          uint32 face_width = 0;
          uint32 face_height = 0;
          for (int i = 0; i < 6; ++i) {
            face_width = std::max(face_width, infos[0].images[0]->GetWidth());
            face_height =
                std::max(face_height, infos[0].images[0]->GetHeight());
          }

          ImagePtr cubemap(new Image);
          const uint32 num_bytes = face_width * 3U * face_height * 4U * 3U;
          base::DataContainerPtr cubemap_data =
              base::DataContainer::CreateOverAllocated<uint8>(
                  num_bytes, NULL, cubemap->GetAllocator());
          cubemap->Set(
              Image::kRgb888, face_width * 3U, face_height * 4U, cubemap_data);
          memset(cubemap_data->GetMutableData<uint8>(), 0, num_bytes);

           ----

           ----
           ----
          WriteFaceIntoCubeMap(face_width, 0U, infos[0].images[4], cubemap);
          WriteFaceIntoCubeMap(0U, face_height, infos[0].images[0], cubemap);
          WriteFaceIntoCubeMap(
              face_width, face_height, infos[0].images[5], cubemap);
          WriteFaceIntoCubeMap(
              face_width * 2U, face_height, infos[0].images[3], cubemap);
          WriteFaceIntoCubeMap(
              face_width, face_height * 2U, infos[0].images[1], cubemap);
          WriteFaceIntoCubeMap(
              face_width, face_height * 3U, infos[0].images[2], cubemap);

          const std::vector<uint8> png_data =
              image::ConvertToExternalImageData(cubemap, image::kPng, false);
          data = base::MimeBase64EncodeString(
              std::string(png_data.begin(), png_data.end()));
        }
      }
    }
  }

  return data;
}

}  // anonymous namespace




ResourceHandler::ResourceHandler(const gfx::RendererPtr& renderer)
    : HttpServer::RequestHandler("/ion/resources"),
      renderer_(renderer) {
  IonRemoteResourcesRoot::RegisterAssetsOnce();
}

ResourceHandler::~ResourceHandler() {}

const std::string ResourceHandler::HandleRequest(
    const std::string& path_in, const HttpServer::QueryMap& args,
    std::string* content_type) {
  const std::string path = path_in.empty() ? "index.html" : path_in;

  if (path == "buffer_data") {
    return GetBufferData(renderer_, args);
  } else if (path == "resources_by_type") {
    *content_type = "application/json";
    return GetResourceList(renderer_, args);
  } else if (path == "texture_data") {
    *content_type = "image/png";
    return GetTextureData(
        renderer_, args, args.find("nonblocking") == args.end());
  } else {
    const std::string& data = base::ZipAssetManager::GetFileData(
        "ion/resources/" + path);
    if (base::IsInvalidReference(data)) {
      return std::string();
    } else {
      if (base::EndsWith(path, "html"))
        *content_type = "text/html";
      return data;
    }
  }
}

}  // namespace remote
}  // namespace ion

#endif