Mojo converters for surfaces API types

This adds type converters for the mojom types in the surfaces API. Most
are idiomatic TypeConverter<> uses, but a few are done by hand as the
chromium type needs to be heap allocated and not copied for one reason or
another.

Review URL: https://codereview.chromium.org/349383002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@280682 0039d316-1c4b-4281-b951-d872f2087c98

14 files changed, 1146 insertions, 12 deletions

diff --git a/mojo/mojo.gyp b/mojo/mojo.gyp
index 69665f1..b8ae404 100644
--- a/mojo/mojo.gyp
+++ b/mojo/mojo.gyp
@@ -58,6 +58,8 @@
         'mojo_shell',
         'mojo_shell_lib',
         'mojo_shell_tests',
+        'mojo_surfaces_lib',
+        'mojo_surfaces_lib_unittests',
         'mojo_system',
         'mojo_system_impl',
         'mojo_system_unittests',
diff --git a/mojo/mojo_services.gypi b/mojo/mojo_services.gypi
index 6386855..2fd4583 100644
--- a/mojo/mojo_services.gypi
+++ b/mojo/mojo_services.gypi
@@ -1,3 +1,7 @@
+# Copyright (c) 2014 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.
+
 {
   'targets': [
     {
@@ -72,14 +76,69 @@
         'MOJO_GEOMETRY_IMPLEMENTATION',
       ],
       'dependencies': [
+        '../skia/skia.gyp:skia',
+        '../ui/gfx/gfx.gyp:gfx',
         '../ui/gfx/gfx.gyp:gfx_geometry',
         'mojo_environment_chromium',
         'mojo_geometry_bindings',
         'mojo_system_impl',
       ],
+      'export_dependent_settings': [
+        '../ui/gfx/gfx.gyp:gfx',
+      ],
       'sources': [
         'services/public/cpp/geometry/lib/geometry_type_converters.cc',
         'services/public/cpp/geometry/geometry_type_converters.h',
+        'services/public/cpp/geometry/mojo_geometry_export.h',
+      ],
+    },
+    {
+      'target_name': 'mojo_surfaces_lib',
+      'type': '<(component)',
+      'defines': [
+        'MOJO_SURFACES_IMPLEMENTATION',
+      ],
+      'dependencies': [
+        '../base/base.gyp:base',
+        '../cc/cc.gyp:cc',
+        '../cc/cc.gyp:cc_surfaces',
+        '../gpu/gpu.gyp:gpu',
+        '../ui/gfx/gfx.gyp:gfx',
+        '../ui/gfx/gfx.gyp:gfx_geometry',
+        'mojo_environment_chromium',
+        'mojo_geometry_lib',
+        'mojo_surfaces_bindings',
+        'mojo_system_impl',
+      ],
+      'export_dependent_settings': [
+        'mojo_geometry_lib',
+      ],
+      'sources': [
+        'services/public/cpp/surfaces/lib/surfaces_type_converters.cc',
+        'services/public/cpp/surfaces/surfaces_type_converters.h',
+        'services/public/cpp/surfaces/mojo_surfaces_export.h',
+      ],
+    },
+    {
+      'target_name': 'mojo_surfaces_lib_unittests',
+      'type': 'executable',
+      'dependencies': [
+        '../base/base.gyp:base',
+        '../base/base.gyp:test_support_base',
+        '../cc/cc.gyp:cc',
+        '../cc/cc.gyp:cc_surfaces',
+        '../gpu/gpu.gyp:gpu',
+        '../skia/skia.gyp:skia',
+        '../testing/gtest.gyp:gtest',
+        '../ui/gfx/gfx.gyp:gfx',
+        '../ui/gfx/gfx.gyp:gfx_geometry',
+        'mojo_geometry_lib',
+        'mojo_run_all_unittests',
+        'mojo_surfaces_bindings',
+        'mojo_surfaces_lib',
+      ],
+      'sources': [
+        'services/public/cpp/surfaces/tests/surface_unittest.cc',
       ],
     },
     {
diff --git a/mojo/services/public/cpp/geometry/DEPS b/mojo/services/public/cpp/geometry/DEPS
index 194be1c..3e03810 100644
--- a/mojo/services/public/cpp/geometry/DEPS
+++ b/mojo/services/public/cpp/geometry/DEPS
@@ -1,3 +1,4 @@
 include_rules = [
   "+ui/gfx/geometry",
+  "+ui/gfx/transform.h",
 ]
diff --git a/mojo/services/public/cpp/geometry/geometry_type_converters.h b/mojo/services/public/cpp/geometry/geometry_type_converters.h
index 3c09f67..80728f9 100644
--- a/mojo/services/public/cpp/geometry/geometry_type_converters.h
+++ b/mojo/services/public/cpp/geometry/geometry_type_converters.h
@@ -7,7 +7,11 @@
 
 #include "mojo/services/public/cpp/geometry/mojo_geometry_export.h"
 #include "mojo/services/public/interfaces/geometry/geometry.mojom.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/point_f.h"
 #include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/transform.h"
 
 namespace mojo {
 
@@ -18,7 +22,14 @@ class MOJO_GEOMETRY_EXPORT TypeConverter<PointPtr, gfx::Point> {
   static gfx::Point ConvertTo(const PointPtr& input);
 };
 
-template<>
+template <>
+class MOJO_GEOMETRY_EXPORT TypeConverter<PointFPtr, gfx::PointF> {
+ public:
+  static PointFPtr ConvertFrom(const gfx::PointF& input);
+  static gfx::PointF ConvertTo(const PointFPtr& input);
+};
+
+template <>
 class MOJO_GEOMETRY_EXPORT TypeConverter<SizePtr, gfx::Size> {
  public:
   static SizePtr ConvertFrom(const gfx::Size& input);
@@ -32,6 +43,13 @@ class MOJO_GEOMETRY_EXPORT TypeConverter<RectPtr, gfx::Rect> {
   static gfx::Rect ConvertTo(const RectPtr& input);
 };
 
+template <>
+class MOJO_GEOMETRY_EXPORT TypeConverter<TransformPtr, gfx::Transform> {
+ public:
+  static TransformPtr ConvertFrom(const gfx::Transform& input);
+  static gfx::Transform ConvertTo(const TransformPtr& input);
+};
+
 }  // namespace mojo
 
 #endif  // MOJO_SERVICES_PUBLIC_CPP_GEOMETRY_GEOMETRY_TYPE_CONVERTERS_H_
diff --git a/mojo/services/public/cpp/geometry/lib/geometry_type_converters.cc b/mojo/services/public/cpp/geometry/lib/geometry_type_converters.cc
index 6d94237..3b9d787 100644
--- a/mojo/services/public/cpp/geometry/lib/geometry_type_converters.cc
+++ b/mojo/services/public/cpp/geometry/lib/geometry_type_converters.cc
@@ -18,12 +18,29 @@ PointPtr TypeConverter<PointPtr, gfx::Point>::ConvertFrom(
 // static
 gfx::Point TypeConverter<PointPtr, gfx::Point>::ConvertTo(
     const PointPtr& input) {
-  if (!input)
+  if (input.is_null())
     return gfx::Point();
   return gfx::Point(input->x, input->y);
 }
 
 // static
+PointFPtr TypeConverter<PointFPtr, gfx::PointF>::ConvertFrom(
+    const gfx::PointF& input) {
+  PointFPtr point(PointF::New());
+  point->x = input.x();
+  point->y = input.y();
+  return point.Pass();
+}
+
+// static
+gfx::PointF TypeConverter<PointFPtr, gfx::PointF>::ConvertTo(
+    const PointFPtr& input) {
+  if (input.is_null())
+    return gfx::PointF();
+  return gfx::PointF(input->x, input->y);
+}
+
+// static
 SizePtr TypeConverter<SizePtr, gfx::Size>::ConvertFrom(const gfx::Size& input) {
   SizePtr size(Size::New());
   size->width = input.width();
@@ -33,7 +50,7 @@ SizePtr TypeConverter<SizePtr, gfx::Size>::ConvertFrom(const gfx::Size& input) {
 
 // static
 gfx::Size TypeConverter<SizePtr, gfx::Size>::ConvertTo(const SizePtr& input) {
-  if (!input)
+  if (input.is_null())
     return gfx::Size();
   return gfx::Size(input->width, input->height);
 }
@@ -50,9 +67,31 @@ RectPtr TypeConverter<RectPtr, gfx::Rect>::ConvertFrom(const gfx::Rect& input) {
 
 // static
 gfx::Rect TypeConverter<RectPtr, gfx::Rect>::ConvertTo(const RectPtr& input) {
-  if (!input)
+  if (input.is_null())
     return gfx::Rect();
   return gfx::Rect(input->x, input->y, input->width, input->height);
 }
 
+// static
+TransformPtr TypeConverter<TransformPtr, gfx::Transform>::ConvertFrom(
+    const gfx::Transform& input) {
+  std::vector<float> storage(16);
+  input.matrix().asRowMajorf(&storage[0]);
+  mojo::Array<float> matrix;
+  matrix.Swap(&storage);
+  TransformPtr transform(Transform::New());
+  transform->matrix = matrix.Pass();
+  return transform.Pass();
+}
+
+// static
+gfx::Transform TypeConverter<TransformPtr, gfx::Transform>::ConvertTo(
+    const TransformPtr& input) {
+  if (input.is_null())
+    return gfx::Transform();
+  gfx::Transform transform(gfx::Transform::kSkipInitialization);
+  transform.matrix().setRowMajorf(&input->matrix.storage()[0]);
+  return transform;
+}
+
 }  // namespace mojo
diff --git a/mojo/services/public/cpp/surfaces/DEPS b/mojo/services/public/cpp/surfaces/DEPS
new file mode 100644
index 0000000..b64283f
--- /dev/null
+++ b/mojo/services/public/cpp/surfaces/DEPS
@@ -0,0 +1,9 @@
+include_rules = [
+  "+cc/output",
+  "+cc/quads",
+  "+cc/resources",
+  "+cc/surfaces",
+  "+gpu/command_buffer/common/mailbox.h",
+  "+gpu/command_buffer/common/mailbox_holder.h",
+  "+third_party/skia/include",
+]
diff --git a/mojo/services/public/cpp/surfaces/lib/surfaces_type_converters.cc b/mojo/services/public/cpp/surfaces/lib/surfaces_type_converters.cc
new file mode 100644
index 0000000..e61ad94
--- /dev/null
+++ b/mojo/services/public/cpp/surfaces/lib/surfaces_type_converters.cc
@@ -0,0 +1,422 @@
+// Copyright 2014 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 "mojo/services/public/cpp/surfaces/surfaces_type_converters.h"
+
+#include "cc/output/compositor_frame.h"
+#include "cc/output/delegated_frame_data.h"
+#include "cc/quads/draw_quad.h"
+#include "cc/quads/render_pass.h"
+#include "cc/quads/shared_quad_state.h"
+#include "cc/quads/solid_color_draw_quad.h"
+#include "cc/quads/surface_draw_quad.h"
+#include "cc/quads/texture_draw_quad.h"
+#include "mojo/services/public/cpp/geometry/geometry_type_converters.h"
+
+namespace mojo {
+
+// static
+surfaces::SurfaceIdPtr
+TypeConverter<surfaces::SurfaceIdPtr, cc::SurfaceId>::ConvertFrom(
+    const cc::SurfaceId& input) {
+  surfaces::SurfaceIdPtr id(surfaces::SurfaceId::New());
+  id->id = input.id;
+  return id.Pass();
+}
+
+// static
+cc::SurfaceId TypeConverter<surfaces::SurfaceIdPtr, cc::SurfaceId>::ConvertTo(
+    const surfaces::SurfaceIdPtr& input) {
+  return cc::SurfaceId(input->id);
+}
+
+// static
+surfaces::ColorPtr TypeConverter<surfaces::ColorPtr, SkColor>::ConvertFrom(
+    const SkColor& input) {
+  surfaces::ColorPtr color(surfaces::Color::New());
+  color->rgba = input;
+  return color.Pass();
+}
+
+// static
+SkColor TypeConverter<surfaces::ColorPtr, SkColor>::ConvertTo(
+    const surfaces::ColorPtr& input) {
+  return input->rgba;
+}
+
+// static
+surfaces::QuadPtr TypeConverter<surfaces::QuadPtr, cc::DrawQuad>::ConvertFrom(
+    const cc::DrawQuad& input) {
+  surfaces::QuadPtr quad = surfaces::Quad::New();
+  quad->material = static_cast<surfaces::Material>(input.material);
+  quad->rect = Rect::From(input.rect);
+  quad->opaque_rect = Rect::From(input.opaque_rect);
+  quad->visible_rect = Rect::From(input.visible_rect);
+  quad->needs_blending = input.needs_blending;
+  // This is intentionally left set to an invalid value here. It's set when
+  // converting an entire pass since it's an index into the pass' shared quad
+  // state list.
+  quad->shared_quad_state_index = -1;
+  switch (input.material) {
+    case cc::DrawQuad::SOLID_COLOR: {
+      const cc::SolidColorDrawQuad* color_quad =
+          cc::SolidColorDrawQuad::MaterialCast(&input);
+      surfaces::SolidColorQuadStatePtr color_state =
+          surfaces::SolidColorQuadState::New();
+      color_state->color = surfaces::Color::From(color_quad->color);
+      color_state->force_anti_aliasing_off =
+          color_quad->force_anti_aliasing_off;
+      quad->solid_color_quad_state = color_state.Pass();
+      break;
+    }
+    case cc::DrawQuad::SURFACE_CONTENT: {
+      const cc::SurfaceDrawQuad* surface_quad =
+          cc::SurfaceDrawQuad::MaterialCast(&input);
+      surfaces::SurfaceQuadStatePtr surface_state =
+          surfaces::SurfaceQuadState::New();
+      surface_state->surface =
+          surfaces::SurfaceId::From(surface_quad->surface_id);
+      quad->surface_quad_state = surface_state.Pass();
+      break;
+    }
+    case cc::DrawQuad::TEXTURE_CONTENT: {
+      const cc::TextureDrawQuad* texture_quad =
+          cc::TextureDrawQuad::MaterialCast(&input);
+      surfaces::TextureQuadStatePtr texture_state =
+          surfaces::TextureQuadState::New();
+      texture_state = surfaces::TextureQuadState::New();
+      texture_state->resource_id = texture_quad->resource_id;
+      texture_state->premultiplied_alpha = texture_quad->premultiplied_alpha;
+      texture_state->uv_top_left = PointF::From(texture_quad->uv_top_left);
+      texture_state->uv_bottom_right =
+          PointF::From(texture_quad->uv_bottom_right);
+      texture_state->background_color =
+          surfaces::Color::From(texture_quad->background_color);
+      Array<float> vertex_opacity(4);
+      for (size_t i = 0; i < 4; ++i) {
+        vertex_opacity[i] = texture_quad->vertex_opacity[i];
+      }
+      texture_state->vertex_opacity = vertex_opacity.Pass();
+      texture_state->flipped = texture_quad->flipped;
+      quad->texture_quad_state = texture_state.Pass();
+      break;
+    }
+    default:
+      NOTREACHED() << "Unsupported material " << input.material;
+  }
+  return quad.Pass();
+}
+
+// static
+scoped_ptr<cc::DrawQuad> ConvertTo(const surfaces::QuadPtr& input,
+                                   cc::SharedQuadState* sqs) {
+  switch (input->material) {
+    case surfaces::SOLID_COLOR: {
+      scoped_ptr<cc::SolidColorDrawQuad> color_quad =
+          cc::SolidColorDrawQuad::Create();
+      color_quad->SetAll(
+          sqs,
+          input->rect.To<gfx::Rect>(),
+          input->opaque_rect.To<gfx::Rect>(),
+          input->visible_rect.To<gfx::Rect>(),
+          input->needs_blending,
+          input->solid_color_quad_state->color.To<SkColor>(),
+          input->solid_color_quad_state->force_anti_aliasing_off);
+      return color_quad.PassAs<cc::DrawQuad>();
+    }
+    case surfaces::SURFACE_CONTENT: {
+      scoped_ptr<cc::SurfaceDrawQuad> surface_quad =
+          cc::SurfaceDrawQuad::Create();
+      surface_quad->SetAll(
+          sqs,
+          input->rect.To<gfx::Rect>(),
+          input->opaque_rect.To<gfx::Rect>(),
+          input->visible_rect.To<gfx::Rect>(),
+          input->needs_blending,
+          input->surface_quad_state->surface.To<cc::SurfaceId>());
+      return surface_quad.PassAs<cc::DrawQuad>();
+    }
+    case surfaces::TEXTURE_CONTENT: {
+      scoped_ptr<cc::TextureDrawQuad> texture_quad =
+          cc::TextureDrawQuad::Create();
+      surfaces::TextureQuadStatePtr& texture_quad_state =
+          input->texture_quad_state;
+      texture_quad->SetAll(
+          sqs,
+          input->rect.To<gfx::Rect>(),
+          input->opaque_rect.To<gfx::Rect>(),
+          input->visible_rect.To<gfx::Rect>(),
+          input->needs_blending,
+          texture_quad_state->resource_id,
+          texture_quad_state->premultiplied_alpha,
+          texture_quad_state->uv_top_left.To<gfx::PointF>(),
+          texture_quad_state->uv_bottom_right.To<gfx::PointF>(),
+          texture_quad_state->background_color.To<SkColor>(),
+          texture_quad_state->vertex_opacity.storage().data(),
+          texture_quad_state->flipped);
+      return texture_quad.PassAs<cc::DrawQuad>();
+    }
+    default:
+      NOTREACHED() << "Unsupported material " << input->material;
+  }
+  return scoped_ptr<cc::DrawQuad>();
+}
+
+// static
+surfaces::SharedQuadStatePtr
+TypeConverter<surfaces::SharedQuadStatePtr, cc::SharedQuadState>::ConvertFrom(
+    const cc::SharedQuadState& input) {
+  surfaces::SharedQuadStatePtr state = surfaces::SharedQuadState::New();
+  state->content_to_target_transform =
+      Transform::From(input.content_to_target_transform);
+  state->content_bounds = Size::From(input.content_bounds);
+  state->visible_content_rect = Rect::From(input.visible_content_rect);
+  state->clip_rect = Rect::From(input.clip_rect);
+  state->is_clipped = input.is_clipped;
+  state->opacity = input.opacity;
+  state->blend_mode = static_cast<surfaces::SkXfermode>(input.blend_mode);
+  state->sorting_context_id = input.sorting_context_id;
+  return state.Pass();
+}
+
+// static
+scoped_ptr<cc::SharedQuadState> ConvertTo(
+    const surfaces::SharedQuadStatePtr& input) {
+  scoped_ptr<cc::SharedQuadState> state(new cc::SharedQuadState);
+  state->SetAll(input->content_to_target_transform.To<gfx::Transform>(),
+                input->content_bounds.To<gfx::Size>(),
+                input->visible_content_rect.To<gfx::Rect>(),
+                input->clip_rect.To<gfx::Rect>(),
+                input->is_clipped,
+                input->opacity,
+                static_cast<SkXfermode::Mode>(input->blend_mode),
+                input->sorting_context_id);
+  return state.Pass();
+}
+
+// static
+surfaces::PassPtr TypeConverter<surfaces::PassPtr, cc::RenderPass>::ConvertFrom(
+    const cc::RenderPass& input) {
+  surfaces::PassPtr pass = surfaces::Pass::New();
+  pass->id = input.id.index;
+  pass->output_rect = Rect::From(input.output_rect);
+  pass->damage_rect = Rect::From(input.damage_rect);
+  pass->transform_to_root_target =
+      Transform::From(input.transform_to_root_target);
+  pass->has_transparent_background = input.has_transparent_background;
+  Array<surfaces::QuadPtr> quads(input.quad_list.size());
+  Array<surfaces::SharedQuadStatePtr> shared_quad_state(
+      input.shared_quad_state_list.size());
+  int sqs_i = -1;
+  const cc::SharedQuadState* last_sqs = NULL;
+  for (size_t i = 0; i < quads.size(); ++i) {
+    const cc::DrawQuad& quad = *input.quad_list[i];
+    quads[i] = surfaces::Quad::From(quad);
+    if (quad.shared_quad_state != last_sqs) {
+      sqs_i++;
+      shared_quad_state[sqs_i] =
+          surfaces::SharedQuadState::From(*input.shared_quad_state_list[i]);
+      last_sqs = quad.shared_quad_state;
+    }
+    quads[i]->shared_quad_state_index = sqs_i;
+  }
+  // We should copy all shared quad states.
+  DCHECK_EQ(static_cast<size_t>(sqs_i + 1), shared_quad_state.size());
+  pass->quads = quads.Pass();
+  pass->shared_quad_states = shared_quad_state.Pass();
+  return pass.Pass();
+}
+
+// static
+scoped_ptr<cc::RenderPass> ConvertTo(const surfaces::PassPtr& input) {
+  scoped_ptr<cc::RenderPass> pass = cc::RenderPass::Create();
+  pass->SetAll(cc::RenderPass::Id(1, input->id),
+               input->output_rect.To<gfx::Rect>(),
+               input->damage_rect.To<gfx::Rect>(),
+               input->transform_to_root_target.To<gfx::Transform>(),
+               input->has_transparent_background);
+  cc::SharedQuadStateList& sqs_list = pass->shared_quad_state_list;
+  sqs_list.reserve(input->shared_quad_states.size());
+  for (size_t i = 0; i < input->shared_quad_states.size(); ++i) {
+    sqs_list.push_back(ConvertTo(input->shared_quad_states[i]));
+  }
+  cc::QuadList& quad_list = pass->quad_list;
+  quad_list.reserve(input->quads.size());
+  for (size_t i = 0; i < input->quads.size(); ++i) {
+    surfaces::QuadPtr quad = input->quads[i].Pass();
+    quad_list.push_back(
+        ConvertTo(quad, sqs_list[quad->shared_quad_state_index]));
+  }
+  return pass.Pass();
+}
+
+// static
+surfaces::MailboxPtr
+TypeConverter<surfaces::MailboxPtr, gpu::Mailbox>::ConvertFrom(
+    const gpu::Mailbox& input) {
+  Array<int8_t> name(64);
+  for (int i = 0; i < 64; ++i) {
+    name[i] = input.name[i];
+  }
+  surfaces::MailboxPtr mailbox(surfaces::Mailbox::New());
+  mailbox->name = name.Pass();
+  return mailbox.Pass();
+}
+
+// static
+gpu::Mailbox TypeConverter<surfaces::MailboxPtr, gpu::Mailbox>::ConvertTo(
+    const surfaces::MailboxPtr& input) {
+  gpu::Mailbox mailbox;
+  mailbox.SetName(input->name.storage().data());
+  return mailbox;
+}
+
+// static
+surfaces::MailboxHolderPtr
+TypeConverter<surfaces::MailboxHolderPtr, gpu::MailboxHolder>::ConvertFrom(
+    const gpu::MailboxHolder& input) {
+  surfaces::MailboxHolderPtr holder(surfaces::MailboxHolder::New());
+  holder->mailbox = surfaces::Mailbox::From<gpu::Mailbox>(input.mailbox);
+  holder->texture_target = input.texture_target;
+  holder->sync_point = input.sync_point;
+  return holder.Pass();
+}
+
+// static
+gpu::MailboxHolder
+TypeConverter<surfaces::MailboxHolderPtr, gpu::MailboxHolder>::ConvertTo(
+    const surfaces::MailboxHolderPtr& input) {
+  gpu::MailboxHolder holder;
+  holder.mailbox = input->mailbox.To<gpu::Mailbox>();
+  holder.texture_target = input->texture_target;
+  holder.sync_point = input->sync_point;
+  return holder;
+}
+
+// static
+surfaces::TransferableResourcePtr TypeConverter<
+    surfaces::TransferableResourcePtr,
+    cc::TransferableResource>::ConvertFrom(const cc::TransferableResource&
+                                               input) {
+  surfaces::TransferableResourcePtr transferable =
+      surfaces::TransferableResource::New();
+  transferable->id = input.id;
+  transferable->format = static_cast<surfaces::ResourceFormat>(input.format);
+  transferable->filter = input.filter;
+  transferable->size = Size::From(input.size);
+  transferable->mailbox_holder =
+      surfaces::MailboxHolder::From(input.mailbox_holder);
+  transferable->is_repeated = input.is_repeated;
+  transferable->is_software = input.is_software;
+  return transferable.Pass();
+}
+
+// static
+cc::TransferableResource
+TypeConverter<surfaces::TransferableResourcePtr, cc::TransferableResource>::
+    ConvertTo(const surfaces::TransferableResourcePtr& input) {
+  cc::TransferableResource transferable;
+  transferable.id = input->id;
+  transferable.format = static_cast<cc::ResourceFormat>(input->format);
+  transferable.filter = input->filter;
+  transferable.size = input->size.To<gfx::Size>();
+  transferable.mailbox_holder = input->mailbox_holder.To<gpu::MailboxHolder>();
+  transferable.is_repeated = input->is_repeated;
+  transferable.is_software = input->is_software;
+  return transferable;
+}
+
+// static
+Array<surfaces::TransferableResourcePtr>
+TypeConverter<Array<surfaces::TransferableResourcePtr>,
+              cc::TransferableResourceArray>::
+    ConvertFrom(const cc::TransferableResourceArray& input) {
+  Array<surfaces::TransferableResourcePtr> resources(input.size());
+  for (size_t i = 0; i < input.size(); ++i) {
+    resources[i] = surfaces::TransferableResource::From(input[i]);
+  }
+  return resources.Pass();
+}
+
+// static
+cc::TransferableResourceArray
+TypeConverter<Array<surfaces::TransferableResourcePtr>,
+              cc::TransferableResourceArray>::
+    ConvertTo(const Array<surfaces::TransferableResourcePtr>& input) {
+  cc::TransferableResourceArray resources(input.size());
+  for (size_t i = 0; i < input.size(); ++i) {
+    resources[i] = input[i].To<cc::TransferableResource>();
+  }
+  return resources;
+}
+
+// static
+surfaces::ReturnedResourcePtr
+TypeConverter<surfaces::ReturnedResourcePtr, cc::ReturnedResource>::ConvertFrom(
+    const cc::ReturnedResource& input) {
+  surfaces::ReturnedResourcePtr returned = surfaces::ReturnedResource::New();
+  returned->id = input.id;
+  returned->sync_point = input.sync_point;
+  returned->count = input.count;
+  returned->lost = input.lost;
+  return returned.Pass();
+}
+
+// static
+cc::ReturnedResource
+TypeConverter<surfaces::ReturnedResourcePtr, cc::ReturnedResource>::ConvertTo(
+    const surfaces::ReturnedResourcePtr& input) {
+  cc::ReturnedResource returned;
+  returned.id = input->id;
+  returned.sync_point = input->sync_point;
+  returned.count = input->count;
+  returned.lost = input->lost;
+  return returned;
+}
+
+// static
+Array<surfaces::ReturnedResourcePtr> TypeConverter<
+    Array<surfaces::ReturnedResourcePtr>,
+    cc::ReturnedResourceArray>::ConvertFrom(const cc::ReturnedResourceArray&
+                                                input) {
+  Array<surfaces::ReturnedResourcePtr> resources(input.size());
+  for (size_t i = 0; i < input.size(); ++i) {
+    resources[i] = surfaces::ReturnedResource::From(input[i]);
+  }
+  return resources.Pass();
+}
+
+// static
+surfaces::FramePtr
+TypeConverter<surfaces::FramePtr, cc::CompositorFrame>::ConvertFrom(
+    const cc::CompositorFrame& input) {
+  surfaces::FramePtr frame = surfaces::Frame::New();
+  DCHECK(input.delegated_frame_data);
+  cc::DelegatedFrameData* frame_data = input.delegated_frame_data.get();
+  frame->resources =
+      Array<surfaces::TransferableResourcePtr>::From(frame_data->resource_list);
+  const cc::RenderPassList& pass_list = frame_data->render_pass_list;
+  frame->passes = Array<surfaces::PassPtr>::New(pass_list.size());
+  for (size_t i = 0; i < pass_list.size(); ++i) {
+    frame->passes[i] = surfaces::Pass::From(*pass_list[i]);
+  }
+  return frame.Pass();
+}
+
+// static
+scoped_ptr<cc::CompositorFrame> ConvertTo(const surfaces::FramePtr& input) {
+  scoped_ptr<cc::DelegatedFrameData> frame_data(new cc::DelegatedFrameData);
+  frame_data->device_scale_factor = 1.f;
+  frame_data->resource_list =
+      input->resources.To<cc::TransferableResourceArray>();
+  frame_data->render_pass_list.reserve(input->passes.size());
+  for (size_t i = 0; i < input->passes.size(); ++i) {
+    frame_data->render_pass_list.push_back(ConvertTo(input->passes[i]));
+  }
+  scoped_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
+  frame->delegated_frame_data = frame_data.Pass();
+  return frame.Pass();
+}
+
+}  // namespace mojo
diff --git a/mojo/services/public/cpp/surfaces/mojo_surfaces_export.h b/mojo/services/public/cpp/surfaces/mojo_surfaces_export.h
new file mode 100644
index 0000000..31b408f
--- /dev/null
+++ b/mojo/services/public/cpp/surfaces/mojo_surfaces_export.h
@@ -0,0 +1,32 @@
+// Copyright 2014 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.
+
+#ifndef MOJO_SERVICES_PUBLIC_CPP_SURFACES_MOJO_SURFACES_EXPORT_H_
+#define MOJO_SERVICES_PUBLIC_CPP_SURFACES_MOJO_SURFACES_EXPORT_H_
+
+#if defined(COMPONENT_BUILD)
+
+#if defined(WIN32)
+
+#if defined(MOJO_SURFACES_IMPLEMENTATION)
+#define MOJO_SURFACES_EXPORT __declspec(dllexport)
+#else
+#define MOJO_SURFACES_EXPORT __declspec(dllimport)
+#endif
+
+#else  // !defined(WIN32)
+
+#if defined(MOJO_SURFACES_IMPLEMENTATION)
+#define MOJO_SURFACES_EXPORT __attribute__((visibility("default")))
+#else
+#define MOJO_SURFACES_EXPORT
+#endif
+
+#endif  // defined(WIN32)
+
+#else  // !defined(COMPONENT_BUILD)
+#define MOJO_SURFACES_EXPORT
+#endif
+
+#endif  // MOJO_SERVICES_PUBLIC_CPP_SURFACES_MOJO_SURFACES_EXPORT_H_
diff --git a/mojo/services/public/cpp/surfaces/surfaces_type_converters.h b/mojo/services/public/cpp/surfaces/surfaces_type_converters.h
new file mode 100644
index 0000000..89abd16
--- /dev/null
+++ b/mojo/services/public/cpp/surfaces/surfaces_type_converters.h
@@ -0,0 +1,149 @@
+// Copyright 2014 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.
+
+#ifndef MOJO_SERVICES_PUBLIC_CPP_SURFACES_SURFACES_TYPE_CONVERTERS_H_
+#define MOJO_SERVICES_PUBLIC_CPP_SURFACES_SURFACES_TYPE_CONVERTERS_H_
+
+#include "base/memory/scoped_ptr.h"
+#include "cc/resources/returned_resource.h"
+#include "cc/resources/transferable_resource.h"
+#include "cc/surfaces/surface_id.h"
+#include "gpu/command_buffer/common/mailbox.h"
+#include "gpu/command_buffer/common/mailbox_holder.h"
+#include "mojo/services/public/cpp/surfaces/mojo_surfaces_export.h"
+#include "mojo/services/public/interfaces/surfaces/quads.mojom.h"
+#include "mojo/services/public/interfaces/surfaces/surface_id.mojom.h"
+#include "mojo/services/public/interfaces/surfaces/surfaces.mojom.h"
+#include "third_party/skia/include/core/SkColor.h"
+
+namespace cc {
+class CompositorFrame;
+class DrawQuad;
+class RenderPass;
+class SharedQuadState;
+}  // namespace cc
+
+namespace mojo {
+
+// Types from surface_id.mojom
+template <>
+class MOJO_SURFACES_EXPORT
+TypeConverter<surfaces::SurfaceIdPtr, cc::SurfaceId> {
+ public:
+  static surfaces::SurfaceIdPtr ConvertFrom(const cc::SurfaceId& input);
+  static cc::SurfaceId ConvertTo(const surfaces::SurfaceIdPtr& input);
+};
+
+// Types from quads.mojom
+template <>
+class MOJO_SURFACES_EXPORT TypeConverter<surfaces::ColorPtr, SkColor> {
+ public:
+  static surfaces::ColorPtr ConvertFrom(const SkColor& input);
+  static SkColor ConvertTo(const surfaces::ColorPtr& input);
+};
+
+template <>
+class MOJO_SURFACES_EXPORT TypeConverter<surfaces::QuadPtr, cc::DrawQuad> {
+ public:
+  static surfaces::QuadPtr ConvertFrom(const cc::DrawQuad& input);
+};
+
+// This can't use the TypeConverter since it has to return a pointer to a type
+// since cc::DrawQuad is polymorphic and needs an additional input. The
+// TypeConverter for surfaces::Pass calls this explicitly.
+MOJO_SURFACES_EXPORT scoped_ptr<cc::DrawQuad> ConvertTo(
+    const surfaces::QuadPtr& input,
+    cc::SharedQuadState* sqs);
+
+template <>
+class MOJO_SURFACES_EXPORT
+TypeConverter<surfaces::SharedQuadStatePtr, cc::SharedQuadState> {
+ public:
+  static surfaces::SharedQuadStatePtr ConvertFrom(
+      const cc::SharedQuadState& input);
+};
+
+MOJO_SURFACES_EXPORT scoped_ptr<cc::SharedQuadState> ConvertTo(
+    const surfaces::SharedQuadStatePtr& input);
+
+template <>
+class MOJO_SURFACES_EXPORT TypeConverter<surfaces::PassPtr, cc::RenderPass> {
+ public:
+  static surfaces::PassPtr ConvertFrom(const cc::RenderPass& input);
+};
+
+// This can't use the TypeConverter since cc::RenderPass must be heap allocated
+// and isn't copyable.
+MOJO_SURFACES_EXPORT scoped_ptr<cc::RenderPass> ConvertTo(
+    const surfaces::PassPtr& input);
+
+// Types from surfaces.mojom
+template <>
+class MOJO_SURFACES_EXPORT TypeConverter<surfaces::MailboxPtr, gpu::Mailbox> {
+ public:
+  static surfaces::MailboxPtr ConvertFrom(const gpu::Mailbox& input);
+  static gpu::Mailbox ConvertTo(const surfaces::MailboxPtr& input);
+};
+
+template <>
+class MOJO_SURFACES_EXPORT
+TypeConverter<surfaces::MailboxHolderPtr, gpu::MailboxHolder> {
+ public:
+  static surfaces::MailboxHolderPtr ConvertFrom(
+      const gpu::MailboxHolder& input);
+  static gpu::MailboxHolder ConvertTo(const surfaces::MailboxHolderPtr& input);
+};
+
+template <>
+class MOJO_SURFACES_EXPORT
+TypeConverter<surfaces::TransferableResourcePtr, cc::TransferableResource> {
+ public:
+  static surfaces::TransferableResourcePtr ConvertFrom(
+      const cc::TransferableResource& input);
+  static cc::TransferableResource ConvertTo(
+      const surfaces::TransferableResourcePtr& input);
+};
+
+template <>
+class MOJO_SURFACES_EXPORT
+TypeConverter<Array<surfaces::TransferableResourcePtr>,
+              cc::TransferableResourceArray> {
+ public:
+  static Array<surfaces::TransferableResourcePtr> ConvertFrom(
+      const cc::TransferableResourceArray& input);
+  static cc::TransferableResourceArray ConvertTo(
+      const Array<surfaces::TransferableResourcePtr>& input);
+};
+
+template <>
+class MOJO_SURFACES_EXPORT
+TypeConverter<surfaces::ReturnedResourcePtr, cc::ReturnedResource> {
+ public:
+  static surfaces::ReturnedResourcePtr ConvertFrom(
+      const cc::ReturnedResource& input);
+  static cc::ReturnedResource ConvertTo(
+      const surfaces::ReturnedResourcePtr& input);
+};
+
+template <>
+class MOJO_SURFACES_EXPORT
+TypeConverter<Array<surfaces::ReturnedResourcePtr>, cc::ReturnedResourceArray> {
+ public:
+  static Array<surfaces::ReturnedResourcePtr> ConvertFrom(
+      const cc::ReturnedResourceArray& input);
+};
+
+template <>
+class MOJO_SURFACES_EXPORT
+TypeConverter<surfaces::FramePtr, cc::CompositorFrame> {
+ public:
+  static surfaces::FramePtr ConvertFrom(const cc::CompositorFrame& input);
+};
+
+MOJO_SURFACES_EXPORT scoped_ptr<cc::CompositorFrame> ConvertTo(
+    const surfaces::FramePtr& input);
+
+}  // namespace mojo
+
+#endif  // MOJO_SERVICES_PUBLIC_CPP_SURFACES_SURFACES_TYPE_CONVERTERS_H_
diff --git a/mojo/services/public/cpp/surfaces/tests/surface_unittest.cc b/mojo/services/public/cpp/surfaces/tests/surface_unittest.cc
new file mode 100644
index 0000000..dfb651b
--- /dev/null
+++ b/mojo/services/public/cpp/surfaces/tests/surface_unittest.cc
@@ -0,0 +1,393 @@
+// Copyright 2014 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 "cc/quads/render_pass.h"
+#include "cc/quads/solid_color_draw_quad.h"
+#include "cc/quads/surface_draw_quad.h"
+#include "cc/quads/texture_draw_quad.h"
+#include "gpu/command_buffer/common/mailbox.h"
+#include "gpu/command_buffer/common/mailbox_holder.h"
+#include "mojo/services/public/cpp/geometry/geometry_type_converters.h"
+#include "mojo/services/public/cpp/surfaces/surfaces_type_converters.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "third_party/skia/include/core/SkXfermode.h"
+
+namespace mojo {
+namespace {
+
+TEST(SurfaceLibTest, SurfaceIdConverterNullId) {
+  cc::SurfaceId null_id;
+  cc::SurfaceId round_trip =
+      surfaces::SurfaceId::From(null_id).To<cc::SurfaceId>();
+  EXPECT_TRUE(round_trip.is_null());
+}
+
+TEST(SurfaceLibTest, SurfaceIdConverterValidId) {
+  cc::SurfaceId valid_id(7);
+  cc::SurfaceId round_trip =
+      surfaces::SurfaceId::From(valid_id).To<cc::SurfaceId>();
+  EXPECT_FALSE(round_trip.is_null());
+  EXPECT_EQ(7, round_trip.id);
+}
+
+TEST(SurfaceLibTest, Color) {
+  SkColor arbitrary_color = SK_ColorMAGENTA;
+  SkColor round_trip = surfaces::Color::From(arbitrary_color).To<SkColor>();
+  EXPECT_EQ(arbitrary_color, round_trip);
+}
+
+class SurfaceLibQuadTest : public testing::Test {
+ public:
+  SurfaceLibQuadTest()
+      : sqs(new cc::SharedQuadState),
+        rect(5, 7, 13, 19),
+        opaque_rect(rect),
+        visible_rect(9, 11, 5, 7),
+        needs_blending(false) {}
+
+ protected:
+  scoped_ptr<cc::SharedQuadState> sqs;
+  gfx::Rect rect;
+  gfx::Rect opaque_rect;
+  gfx::Rect visible_rect;
+  bool needs_blending;
+};
+
+TEST_F(SurfaceLibQuadTest, ColorQuad) {
+  scoped_ptr<cc::SolidColorDrawQuad> color_quad =
+      cc::SolidColorDrawQuad::Create();
+  SkColor arbitrary_color = SK_ColorGREEN;
+  bool force_anti_aliasing_off = true;
+  color_quad->SetAll(sqs.get(),
+                     rect,
+                     opaque_rect,
+                     visible_rect,
+                     needs_blending,
+                     arbitrary_color,
+                     force_anti_aliasing_off);
+
+  cc::DrawQuad* base_ptr = static_cast<cc::DrawQuad*>(color_quad.get());
+  surfaces::QuadPtr mojo_quad = surfaces::Quad::From(*base_ptr);
+  ASSERT_FALSE(mojo_quad.is_null());
+  EXPECT_EQ(surfaces::SOLID_COLOR, mojo_quad->material);
+  EXPECT_EQ(Rect::From(rect), mojo_quad->rect);
+  EXPECT_EQ(Rect::From(opaque_rect), mojo_quad->opaque_rect);
+  EXPECT_EQ(Rect::From(visible_rect), mojo_quad->visible_rect);
+  EXPECT_EQ(needs_blending, mojo_quad->needs_blending);
+  ASSERT_TRUE(mojo_quad->solid_color_quad_state);
+  surfaces::SolidColorQuadStatePtr& mojo_color_state =
+      mojo_quad->solid_color_quad_state;
+  EXPECT_EQ(surfaces::Color::From(arbitrary_color), mojo_color_state->color);
+  EXPECT_EQ(force_anti_aliasing_off, mojo_color_state->force_anti_aliasing_off);
+
+  scoped_ptr<cc::DrawQuad> round_trip_quad =
+      ConvertTo(mojo_quad.Pass(), sqs.get());
+  EXPECT_EQ(rect, round_trip_quad->rect);
+  EXPECT_EQ(opaque_rect, round_trip_quad->opaque_rect);
+  EXPECT_EQ(visible_rect, round_trip_quad->visible_rect);
+  EXPECT_EQ(needs_blending, round_trip_quad->needs_blending);
+  ASSERT_EQ(cc::DrawQuad::SOLID_COLOR, round_trip_quad->material);
+  const cc::SolidColorDrawQuad* round_trip_color_quad =
+      cc::SolidColorDrawQuad::MaterialCast(round_trip_quad.get());
+  EXPECT_EQ(arbitrary_color, round_trip_color_quad->color);
+  EXPECT_EQ(force_anti_aliasing_off,
+            round_trip_color_quad->force_anti_aliasing_off);
+}
+
+TEST_F(SurfaceLibQuadTest, SurfaceQuad) {
+  scoped_ptr<cc::SurfaceDrawQuad> surface_quad = cc::SurfaceDrawQuad::Create();
+  cc::SurfaceId arbitrary_id(5);
+  surface_quad->SetAll(
+      sqs.get(), rect, opaque_rect, visible_rect, needs_blending, arbitrary_id);
+  cc::DrawQuad* base_ptr = static_cast<cc::DrawQuad*>(surface_quad.get());
+  surfaces::QuadPtr mojo_quad = surfaces::Quad::From(*base_ptr);
+  ASSERT_FALSE(mojo_quad.is_null());
+  EXPECT_EQ(surfaces::SURFACE_CONTENT, mojo_quad->material);
+  ASSERT_TRUE(mojo_quad->surface_quad_state);
+  surfaces::SurfaceQuadStatePtr& mojo_surface_state =
+      mojo_quad->surface_quad_state;
+  EXPECT_EQ(surfaces::SurfaceId::From(arbitrary_id),
+            mojo_surface_state->surface);
+
+  scoped_ptr<cc::DrawQuad> round_trip_quad =
+      ConvertTo(mojo_quad.Pass(), sqs.get());
+  ASSERT_EQ(cc::DrawQuad::SURFACE_CONTENT, round_trip_quad->material);
+  const cc::SurfaceDrawQuad* round_trip_surface_quad =
+      cc::SurfaceDrawQuad::MaterialCast(round_trip_quad.get());
+  EXPECT_EQ(arbitrary_id, round_trip_surface_quad->surface_id);
+}
+
+TEST_F(SurfaceLibQuadTest, TextureQuad) {
+  scoped_ptr<cc::TextureDrawQuad> texture_quad = cc::TextureDrawQuad::Create();
+  unsigned resource_id = 9;
+  bool premultiplied_alpha = true;
+  gfx::PointF uv_top_left(1.7f, 2.1f);
+  gfx::PointF uv_bottom_right(-7.f, 16.3f);
+  SkColor background_color = SK_ColorYELLOW;
+  float vertex_opacity[4] = {0.1f, 0.5f, 0.4f, 0.8f};
+  bool flipped = false;
+  texture_quad->SetAll(sqs.get(),
+                       rect,
+                       opaque_rect,
+                       visible_rect,
+                       needs_blending,
+                       resource_id,
+                       premultiplied_alpha,
+                       uv_top_left,
+                       uv_bottom_right,
+                       background_color,
+                       vertex_opacity,
+                       flipped);
+
+  cc::DrawQuad* base_ptr = static_cast<cc::DrawQuad*>(texture_quad.get());
+  surfaces::QuadPtr mojo_quad = surfaces::Quad::From(*base_ptr);
+  ASSERT_FALSE(mojo_quad.is_null());
+  EXPECT_EQ(surfaces::TEXTURE_CONTENT, mojo_quad->material);
+  ASSERT_TRUE(mojo_quad->texture_quad_state);
+  surfaces::TextureQuadStatePtr& mojo_texture_state =
+      mojo_quad->texture_quad_state;
+  EXPECT_EQ(resource_id, mojo_texture_state->resource_id);
+  EXPECT_EQ(premultiplied_alpha, mojo_texture_state->premultiplied_alpha);
+  EXPECT_EQ(PointF::From(uv_top_left), mojo_texture_state->uv_top_left);
+  EXPECT_EQ(PointF::From(uv_bottom_right), mojo_texture_state->uv_bottom_right);
+  EXPECT_EQ(surfaces::Color::From(background_color),
+            mojo_texture_state->background_color);
+  for (size_t i = 0; i < 4; ++i) {
+    EXPECT_EQ(vertex_opacity[i], mojo_texture_state->vertex_opacity[i]) << i;
+  }
+  EXPECT_EQ(flipped, mojo_texture_state->flipped);
+
+  scoped_ptr<cc::DrawQuad> round_trip_quad =
+      ConvertTo(mojo_quad.Pass(), sqs.get());
+  ASSERT_EQ(cc::DrawQuad::TEXTURE_CONTENT, round_trip_quad->material);
+  const cc::TextureDrawQuad* round_trip_surface_quad =
+      cc::TextureDrawQuad::MaterialCast(round_trip_quad.get());
+  EXPECT_EQ(resource_id, round_trip_surface_quad->resource_id);
+  EXPECT_EQ(premultiplied_alpha, round_trip_surface_quad->premultiplied_alpha);
+  EXPECT_EQ(uv_top_left, round_trip_surface_quad->uv_top_left);
+  EXPECT_EQ(uv_bottom_right, round_trip_surface_quad->uv_bottom_right);
+  EXPECT_EQ(background_color, round_trip_surface_quad->background_color);
+  for (size_t i = 0; i < 4; ++i) {
+    EXPECT_EQ(vertex_opacity[i], round_trip_surface_quad->vertex_opacity[i])
+        << i;
+  }
+  EXPECT_EQ(flipped, round_trip_surface_quad->flipped);
+}
+
+TEST(SurfaceLibTest, SharedQuadState) {
+  gfx::Transform content_to_target_transform;
+  content_to_target_transform.Scale3d(0.3f, 0.7f, 0.9f);
+  gfx::Size content_bounds(57, 39);
+  gfx::Rect visible_content_rect(3, 7, 28, 42);
+  gfx::Rect clip_rect(9, 12, 21, 31);
+  bool is_clipped = true;
+  float opacity = 0.65f;
+  int sorting_context_id = 13;
+  SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode;
+  scoped_ptr<cc::SharedQuadState> sqs(new cc::SharedQuadState);
+  sqs->SetAll(content_to_target_transform,
+              content_bounds,
+              visible_content_rect,
+              clip_rect,
+              is_clipped,
+              opacity,
+              blend_mode,
+              sorting_context_id);
+
+  surfaces::SharedQuadStatePtr mojo_sqs = surfaces::SharedQuadState::From(*sqs);
+  ASSERT_FALSE(mojo_sqs.is_null());
+  EXPECT_EQ(Transform::From(content_to_target_transform),
+            mojo_sqs->content_to_target_transform);
+  EXPECT_EQ(Size::From(content_bounds), mojo_sqs->content_bounds);
+  EXPECT_EQ(Rect::From(visible_content_rect), mojo_sqs->visible_content_rect);
+  EXPECT_EQ(Rect::From(clip_rect), mojo_sqs->clip_rect);
+  EXPECT_EQ(is_clipped, mojo_sqs->is_clipped);
+  EXPECT_EQ(opacity, mojo_sqs->opacity);
+  EXPECT_EQ(sorting_context_id, mojo_sqs->sorting_context_id);
+
+  scoped_ptr<cc::SharedQuadState> round_trip_sqs = ConvertTo(mojo_sqs.Pass());
+  EXPECT_EQ(content_to_target_transform,
+            round_trip_sqs->content_to_target_transform);
+  EXPECT_EQ(content_bounds, round_trip_sqs->content_bounds);
+  EXPECT_EQ(visible_content_rect, round_trip_sqs->visible_content_rect);
+  EXPECT_EQ(clip_rect, round_trip_sqs->clip_rect);
+  EXPECT_EQ(is_clipped, round_trip_sqs->is_clipped);
+  EXPECT_EQ(opacity, round_trip_sqs->opacity);
+  EXPECT_EQ(sorting_context_id, round_trip_sqs->sorting_context_id);
+}
+
+TEST_F(SurfaceLibQuadTest, RenderPass) {
+  scoped_ptr<cc::RenderPass> pass = cc::RenderPass::Create();
+  cc::RenderPass::Id pass_id(1, 6);
+  gfx::Rect output_rect(4, 9, 13, 71);
+  gfx::Rect damage_rect(9, 17, 41, 45);
+  gfx::Transform transform_to_root_target;
+  transform_to_root_target.SkewY(43.0);
+  bool has_transparent_background = false;
+  pass->SetAll(pass_id,
+               output_rect,
+               damage_rect,
+               transform_to_root_target,
+               has_transparent_background);
+
+  gfx::Transform content_to_target_transform;
+  content_to_target_transform.Scale3d(0.3f, 0.7f, 0.9f);
+  gfx::Size content_bounds(57, 39);
+  gfx::Rect visible_content_rect(3, 7, 28, 42);
+  gfx::Rect clip_rect(9, 12, 21, 31);
+  bool is_clipped = true;
+  float opacity = 0.65f;
+  int sorting_context_id = 13;
+  SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode;
+  scoped_ptr<cc::SharedQuadState> sqs(new cc::SharedQuadState);
+  sqs->SetAll(content_to_target_transform,
+              content_bounds,
+              visible_content_rect,
+              clip_rect,
+              is_clipped,
+              opacity,
+              blend_mode,
+              sorting_context_id);
+  pass->shared_quad_state_list.push_back(sqs.Pass());
+
+  scoped_ptr<cc::SolidColorDrawQuad> color_quad =
+      cc::SolidColorDrawQuad::Create();
+  SkColor arbitrary_color = SK_ColorGREEN;
+  bool force_anti_aliasing_off = true;
+  color_quad->SetAll(pass->shared_quad_state_list.back(),
+                     rect,
+                     opaque_rect,
+                     visible_rect,
+                     needs_blending,
+                     arbitrary_color,
+                     force_anti_aliasing_off);
+  pass->quad_list.push_back(color_quad.PassAs<cc::DrawQuad>());
+
+  surfaces::PassPtr mojo_pass = surfaces::Pass::From(*pass);
+  ASSERT_FALSE(mojo_pass.is_null());
+  EXPECT_EQ(6, mojo_pass->id);
+  EXPECT_EQ(Rect::From(output_rect), mojo_pass->output_rect);
+  EXPECT_EQ(Rect::From(damage_rect), mojo_pass->damage_rect);
+  EXPECT_EQ(Transform::From(transform_to_root_target),
+            mojo_pass->transform_to_root_target);
+  EXPECT_EQ(has_transparent_background, mojo_pass->has_transparent_background);
+  ASSERT_EQ(1u, mojo_pass->shared_quad_states.size());
+  ASSERT_EQ(1u, mojo_pass->quads.size());
+  EXPECT_EQ(0, mojo_pass->quads[0]->shared_quad_state_index);
+
+  scoped_ptr<cc::RenderPass> round_trip_pass = ConvertTo(mojo_pass.Pass());
+  EXPECT_EQ(pass_id, round_trip_pass->id);
+  EXPECT_EQ(output_rect, round_trip_pass->output_rect);
+  EXPECT_EQ(damage_rect, round_trip_pass->damage_rect);
+  EXPECT_EQ(transform_to_root_target,
+            round_trip_pass->transform_to_root_target);
+  EXPECT_EQ(has_transparent_background,
+            round_trip_pass->has_transparent_background);
+  ASSERT_EQ(1u, round_trip_pass->shared_quad_state_list.size());
+  ASSERT_EQ(1u, round_trip_pass->quad_list.size());
+  EXPECT_EQ(round_trip_pass->shared_quad_state_list.front(),
+            round_trip_pass->quad_list[0]->shared_quad_state);
+}
+
+TEST(SurfaceLibTest, Mailbox) {
+  gpu::Mailbox mailbox;
+  mailbox.Generate();
+
+  surfaces::MailboxPtr mojo_mailbox = surfaces::Mailbox::From(mailbox);
+  EXPECT_EQ(0, memcmp(mailbox.name, mojo_mailbox->name.storage().data(), 64));
+
+  gpu::Mailbox round_trip_mailbox = mojo_mailbox.To<gpu::Mailbox>();
+  EXPECT_EQ(mailbox, round_trip_mailbox);
+}
+
+TEST(SurfaceLibTest, MailboxHolder) {
+  gpu::Mailbox mailbox;
+  mailbox.Generate();
+  uint32_t texture_target = GL_TEXTURE_2D;
+  uint32_t sync_point = 7u;
+  gpu::MailboxHolder holder(mailbox, texture_target, sync_point);
+
+  surfaces::MailboxHolderPtr mojo_holder =
+      surfaces::MailboxHolder::From(holder);
+  EXPECT_EQ(texture_target, mojo_holder->texture_target);
+  EXPECT_EQ(sync_point, mojo_holder->sync_point);
+
+  gpu::MailboxHolder round_trip_holder = mojo_holder.To<gpu::MailboxHolder>();
+  EXPECT_EQ(mailbox, round_trip_holder.mailbox);
+  EXPECT_EQ(texture_target, round_trip_holder.texture_target);
+  EXPECT_EQ(sync_point, round_trip_holder.sync_point);
+}
+
+TEST(SurfaceLibTest, TransferableResource) {
+  uint32_t id = 7u;
+  cc::ResourceFormat format = cc::BGRA_8888;
+  uint32_t filter = 123u;
+  gfx::Size size(17, 18);
+  gpu::MailboxHolder mailbox_holder;
+  bool is_repeated = false;
+  ;
+  bool is_software = false;
+  cc::TransferableResource resource;
+  resource.id = id;
+  resource.format = format;
+  resource.filter = filter;
+  resource.size = size;
+  resource.mailbox_holder = mailbox_holder;
+  resource.is_repeated = is_repeated;
+  resource.is_software = is_software;
+
+  surfaces::TransferableResourcePtr mojo_resource =
+      surfaces::TransferableResource::From(resource);
+  EXPECT_EQ(id, mojo_resource->id);
+  EXPECT_EQ(static_cast<surfaces::ResourceFormat>(format),
+            mojo_resource->format);
+  EXPECT_EQ(filter, mojo_resource->filter);
+  EXPECT_EQ(Size::From(size), mojo_resource->size);
+  EXPECT_EQ(is_repeated, mojo_resource->is_repeated);
+  EXPECT_EQ(is_software, mojo_resource->is_software);
+
+  cc::TransferableResource round_trip_resource =
+      mojo_resource.To<cc::TransferableResource>();
+  EXPECT_EQ(id, round_trip_resource.id);
+  EXPECT_EQ(format, round_trip_resource.format);
+  EXPECT_EQ(filter, round_trip_resource.filter);
+  EXPECT_EQ(size, round_trip_resource.size);
+  EXPECT_EQ(mailbox_holder.mailbox, round_trip_resource.mailbox_holder.mailbox);
+  EXPECT_EQ(mailbox_holder.texture_target,
+            round_trip_resource.mailbox_holder.texture_target);
+  EXPECT_EQ(mailbox_holder.sync_point,
+            round_trip_resource.mailbox_holder.sync_point);
+  EXPECT_EQ(is_repeated, round_trip_resource.is_repeated);
+  EXPECT_EQ(is_software, round_trip_resource.is_software);
+}
+
+TEST(SurfaceLibTest, ReturnedResource) {
+  uint32_t id = 5u;
+  uint32_t sync_point = 24u;
+  int count = 2;
+  bool lost = false;
+  cc::ReturnedResource resource;
+  resource.id = id;
+  resource.sync_point = sync_point;
+  resource.count = count;
+  resource.lost = lost;
+
+  surfaces::ReturnedResourcePtr mojo_resource =
+      surfaces::ReturnedResource::From(resource);
+  EXPECT_EQ(id, mojo_resource->id);
+  EXPECT_EQ(sync_point, mojo_resource->sync_point);
+  EXPECT_EQ(count, mojo_resource->count);
+  EXPECT_EQ(lost, mojo_resource->lost);
+
+  cc::ReturnedResource round_trip_resource =
+      mojo_resource.To<cc::ReturnedResource>();
+  EXPECT_EQ(id, round_trip_resource.id);
+  EXPECT_EQ(sync_point, round_trip_resource.sync_point);
+  EXPECT_EQ(count, round_trip_resource.count);
+  EXPECT_EQ(lost, round_trip_resource.lost);
+}
+
+}  // namespace
+}  // namespace mojo
diff --git a/mojo/services/public/interfaces/geometry/geometry.mojom b/mojo/services/public/interfaces/geometry/geometry.mojom
index 13cb4a7..da31e12 100644
--- a/mojo/services/public/interfaces/geometry/geometry.mojom
+++ b/mojo/services/public/interfaces/geometry/geometry.mojom
@@ -27,6 +27,7 @@ struct Rect {
 };
 
 struct Transform {
+  // Row major order.
   float[16] matrix;
 };
 
diff --git a/mojo/services/public/interfaces/surfaces/quads.mojom b/mojo/services/public/interfaces/surfaces/quads.mojom
index ab0d3fc..b6b67a4 100644
--- a/mojo/services/public/interfaces/surfaces/quads.mojom
+++ b/mojo/services/public/interfaces/surfaces/quads.mojom
@@ -22,6 +22,7 @@ struct RenderPassQuadState {};
 
 struct SolidColorQuadState {
   Color color;
+  bool force_anti_aliasing_off;
 };
 
 struct SurfaceQuadState {
@@ -34,8 +35,7 @@ struct TextureQuadState {
   mojo.PointF uv_top_left;
   mojo.PointF uv_bottom_right;
   Color background_color;
-  // Should have exactly 4 entries.
-  float[] vertex_opacity;
+  float[4] vertex_opacity;
   bool flipped;
 };
 
@@ -49,6 +49,7 @@ enum Material {
   CHECKERBOARD = 1,
   DEBUG_BORDER,
   IO_SURFACE_CONTENT,
+  PICTURE_CONTENT,
   RENDER_PASS,
   SOLID_COLOR,
   STREAM_VIDEO_CONTENT,
@@ -150,6 +151,7 @@ struct SharedQuadState {
   bool is_clipped;
   float opacity;
   SkXfermode blend_mode;
+  int32 sorting_context_id;
 };
 
 struct Pass {
@@ -157,7 +159,7 @@ struct Pass {
   mojo.Rect output_rect;
   mojo.Rect damage_rect;
   mojo.Transform transform_to_root_target;
-  bool has_transparent_pixels;
+  bool has_transparent_background;
   Quad[] quads;
   SharedQuadState[] shared_quad_states;
 };
diff --git a/mojo/services/public/interfaces/surfaces/surfaces.mojom b/mojo/services/public/interfaces/surfaces/surfaces.mojom
index d83ebb0..f9c5468 100644
--- a/mojo/services/public/interfaces/surfaces/surfaces.mojom
+++ b/mojo/services/public/interfaces/surfaces/surfaces.mojom
@@ -18,8 +18,7 @@ enum ResourceFormat {
 };
 
 struct Mailbox {
-  // Should have exactly 64 entries.
-  int8[] name;
+  int8[64] name;
 };
 
 struct MailboxHolder {
@@ -38,18 +37,25 @@ struct TransferableResource {
   bool is_software;
 };
 
+struct ReturnedResource {
+  uint32 id;
+  uint32 sync_point;
+  int32 count;
+  bool lost;
+};
+
 struct Frame {
   TransferableResource[] resources;
   Pass[] passes;
 };
 
 interface SurfaceClient {
-  ReturnResources(TransferableResource[] resources);
+  ReturnResources(ReturnedResource[] resources);
 };
 
-[client=SurfaceClient]
+[Client=SurfaceClient]
 interface Surface {
-  CreateSurface(SurfaceId id, mojo.Size size);
+  CreateSurface(mojo.Size size) => (SurfaceId id);
   SubmitFrame(SurfaceId id, Frame frame);
   DestroySurface(SurfaceId id);
 };
diff --git a/mojo/tools/data/unittests b/mojo/tools/data/unittests
index 7939ae2..bec28ba 100644
--- a/mojo/tools/data/unittests
+++ b/mojo/tools/data/unittests
@@ -17,6 +17,7 @@ mojo_common_unittests
 mojo_service_manager_unittests
 mojo_view_manager_lib_unittests
 mojo_view_manager_unittests
+mojo_surface_lib_unittests
 
 # JavaScript tests:
 *mojo_apps_js_unittests