Remove extraneous namespaces

mojo/services/public/cpp/surfaces/lib/surfaces_type_converters.cc

Index: mojo/services/public/cpp/surfaces/lib/surfaces_type_converters.cc
diff --git a/mojo/services/public/cpp/surfaces/lib/surfaces_type_converters.cc b/mojo/services/public/cpp/surfaces/lib/surfaces_type_converters.cc
index b30f999934b5158a2f3981bb65f6b426c3ce1c7c..309d1a145b4f29f157d566b4abb09aa1268b8738 100644
--- a/mojo/services/public/cpp/surfaces/lib/surfaces_type_converters.cc
+++ b/mojo/services/public/cpp/surfaces/lib/surfaces_type_converters.cc
@@ -19,7 +19,7 @@ namespace mojo {
 
 #define ASSERT_ENUM_VALUES_EQUAL(value)                                      \
   COMPILE_ASSERT(cc::DrawQuad::value == static_cast<cc::DrawQuad::Material>( \
-                                            surfaces::MATERIAL_##value),     \
+                                            MATERIAL_##value),     \
                  value##_enum_value_matches)
 
 ASSERT_ENUM_VALUES_EQUAL(CHECKERBOARD);
@@ -37,7 +37,7 @@ ASSERT_ENUM_VALUES_EQUAL(YUV_VIDEO_CONTENT);
 namespace {
 
 cc::SharedQuadState* ConvertToSharedQuadState(
-    const surfaces::SharedQuadStatePtr& input,
+    const SharedQuadStatePtr& input,
     cc::RenderPass* render_pass) {
   cc::SharedQuadState* state = render_pass->CreateAndAppendSharedQuadState();
   state->SetAll(input->content_to_target_transform.To<gfx::Transform>(),
@@ -46,16 +46,16 @@ cc::SharedQuadState* ConvertToSharedQuadState(
                 input->clip_rect.To<gfx::Rect>(),
                 input->is_clipped,
                 input->opacity,
-                static_cast<SkXfermode::Mode>(input->blend_mode),
+                static_cast<::SkXfermode::Mode>(input->blend_mode),
                 input->sorting_context_id);
   return state;
 }
 
-bool ConvertToDrawQuad(const surfaces::QuadPtr& input,
+bool ConvertToDrawQuad(const QuadPtr& input,
                        cc::SharedQuadState* sqs,
                        cc::RenderPass* render_pass) {
   switch (input->material) {
-    case surfaces::MATERIAL_SOLID_COLOR: {
+    case MATERIAL_SOLID_COLOR: {
       if (input->solid_color_quad_state.is_null())
         return false;
       cc::SolidColorDrawQuad* color_quad =
@@ -70,7 +70,7 @@ bool ConvertToDrawQuad(const surfaces::QuadPtr& input,
           input->solid_color_quad_state->force_anti_aliasing_off);
       break;
     }
-    case surfaces::MATERIAL_SURFACE_CONTENT: {
+    case MATERIAL_SURFACE_CONTENT: {
       if (input->surface_quad_state.is_null())
         return false;
       cc::SurfaceDrawQuad* surface_quad =
@@ -84,8 +84,8 @@ bool ConvertToDrawQuad(const surfaces::QuadPtr& input,
           input->surface_quad_state->surface.To<cc::SurfaceId>());
       break;
     }
-    case surfaces::MATERIAL_TEXTURE_CONTENT: {
-      surfaces::TextureQuadStatePtr& texture_quad_state =
+    case MATERIAL_TEXTURE_CONTENT: {
+      TextureQuadStatePtr& texture_quad_state =
           input->texture_quad_state;
       if (texture_quad_state.is_null() ||
           texture_quad_state->vertex_opacity.is_null() ||
@@ -118,39 +118,39 @@ bool ConvertToDrawQuad(const surfaces::QuadPtr& input,
 }  // namespace
 
 // static
-surfaces::SurfaceIdPtr
-TypeConverter<surfaces::SurfaceIdPtr, cc::SurfaceId>::ConvertFrom(
+SurfaceIdPtr
+TypeConverter<SurfaceIdPtr, cc::SurfaceId>::ConvertFrom(
     const cc::SurfaceId& input) {
-  surfaces::SurfaceIdPtr id(surfaces::SurfaceId::New());
+  SurfaceIdPtr id(SurfaceId::New());
   id->id = input.id;
   return id.Pass();
 }
 
 // static
-cc::SurfaceId TypeConverter<surfaces::SurfaceIdPtr, cc::SurfaceId>::ConvertTo(
-    const surfaces::SurfaceIdPtr& input) {
+cc::SurfaceId TypeConverter<SurfaceIdPtr, cc::SurfaceId>::ConvertTo(
+    const SurfaceIdPtr& input) {
   return cc::SurfaceId(input->id);
 }
 
 // static
-surfaces::ColorPtr TypeConverter<surfaces::ColorPtr, SkColor>::ConvertFrom(
+ColorPtr TypeConverter<ColorPtr, SkColor>::ConvertFrom(
     const SkColor& input) {
-  surfaces::ColorPtr color(surfaces::Color::New());
+  ColorPtr color(Color::New());
   color->rgba = input;
   return color.Pass();
 }
 
 // static
-SkColor TypeConverter<surfaces::ColorPtr, SkColor>::ConvertTo(
-    const surfaces::ColorPtr& input) {
+SkColor TypeConverter<ColorPtr, SkColor>::ConvertTo(
+    const ColorPtr& input) {
   return input->rgba;
 }
 
 // static
-surfaces::QuadPtr TypeConverter<surfaces::QuadPtr, cc::DrawQuad>::ConvertFrom(
+QuadPtr TypeConverter<QuadPtr, cc::DrawQuad>::ConvertFrom(
     const cc::DrawQuad& input) {
-  surfaces::QuadPtr quad = surfaces::Quad::New();
-  quad->material = static_cast<surfaces::Material>(input.material);
+  QuadPtr quad = Quad::New();
+  quad->material = static_cast<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);
@@ -163,9 +163,8 @@ surfaces::QuadPtr TypeConverter<surfaces::QuadPtr, cc::DrawQuad>::ConvertFrom(
     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);
+      SolidColorQuadStatePtr color_state = SolidColorQuadState::New();
+      color_state->color = 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();
@@ -174,26 +173,24 @@ surfaces::QuadPtr TypeConverter<surfaces::QuadPtr, cc::DrawQuad>::ConvertFrom(
     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);
+      SurfaceQuadStatePtr surface_state =
+          SurfaceQuadState::New();
+      surface_state->surface = 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();
+      TextureQuadStatePtr texture_state = TextureQuadState::New();
+      texture_state = 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);
+          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];
@@ -210,10 +207,10 @@ surfaces::QuadPtr TypeConverter<surfaces::QuadPtr, cc::DrawQuad>::ConvertFrom(
 }
 
 // static
-surfaces::SharedQuadStatePtr
-TypeConverter<surfaces::SharedQuadStatePtr, cc::SharedQuadState>::ConvertFrom(
+SharedQuadStatePtr
+TypeConverter<SharedQuadStatePtr, cc::SharedQuadState>::ConvertFrom(
     const cc::SharedQuadState& input) {
-  surfaces::SharedQuadStatePtr state = surfaces::SharedQuadState::New();
+  SharedQuadStatePtr state = SharedQuadState::New();
   state->content_to_target_transform =
       Transform::From(input.content_to_target_transform);
   state->content_bounds = Size::From(input.content_bounds);
@@ -221,33 +218,33 @@ TypeConverter<surfaces::SharedQuadStatePtr, cc::SharedQuadState>::ConvertFrom(
   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->blend_mode = static_cast<SkXfermode>(input.blend_mode);
   state->sorting_context_id = input.sorting_context_id;
   return state.Pass();
 }
 
 // static
-surfaces::PassPtr TypeConverter<surfaces::PassPtr, cc::RenderPass>::ConvertFrom(
+PassPtr TypeConverter<PassPtr, cc::RenderPass>::ConvertFrom(
     const cc::RenderPass& input) {
-  surfaces::PassPtr pass = surfaces::Pass::New();
+  PassPtr pass = 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(
+  Array<QuadPtr> quads(input.quad_list.size());
+  Array<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);
+    quads[i] = 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]);
+          SharedQuadState::From(*input.shared_quad_state_list[i]);
       last_sqs = quad.shared_quad_state;
     }
     quads[i]->shared_quad_state_index = sqs_i;
@@ -260,7 +257,7 @@ surfaces::PassPtr TypeConverter<surfaces::PassPtr, cc::RenderPass>::ConvertFrom(
 }
 
 // static
-scoped_ptr<cc::RenderPass> ConvertTo(const surfaces::PassPtr& input) {
+scoped_ptr<cc::RenderPass> ConvertTo(const PassPtr& input) {
   scoped_ptr<cc::RenderPass> pass = cc::RenderPass::Create();
   pass->SetAll(cc::RenderPass::Id(1, input->id),
                input->output_rect.To<gfx::Rect>(),
@@ -274,7 +271,7 @@ scoped_ptr<cc::RenderPass> ConvertTo(const surfaces::PassPtr& input) {
   }
   pass->quad_list.reserve(input->quads.size());
   for (size_t i = 0; i < input->quads.size(); ++i) {
-    surfaces::QuadPtr quad = input->quads[i].Pass();
+    QuadPtr quad = input->quads[i].Pass();
     if (!ConvertToDrawQuad(
             quad, sqs_list[quad->shared_quad_state_index], pass.get()))
       return scoped_ptr<cc::RenderPass>();
@@ -283,21 +280,20 @@ scoped_ptr<cc::RenderPass> ConvertTo(const surfaces::PassPtr& input) {
 }
 
 // static
-surfaces::MailboxPtr
-TypeConverter<surfaces::MailboxPtr, gpu::Mailbox>::ConvertFrom(
+MailboxPtr TypeConverter<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());
+  MailboxPtr mailbox(Mailbox::New());
   mailbox->name = name.Pass();
   return mailbox.Pass();
 }
 
 // static
-gpu::Mailbox TypeConverter<surfaces::MailboxPtr, gpu::Mailbox>::ConvertTo(
-    const surfaces::MailboxPtr& input) {
+gpu::Mailbox TypeConverter<MailboxPtr, gpu::Mailbox>::ConvertTo(
+    const MailboxPtr& input) {
   gpu::Mailbox mailbox;
   if (!input->name.is_null())
     mailbox.SetName(&input->name.storage()[0]);
@@ -305,11 +301,11 @@ gpu::Mailbox TypeConverter<surfaces::MailboxPtr, gpu::Mailbox>::ConvertTo(
 }
 
 // static
-surfaces::MailboxHolderPtr
-TypeConverter<surfaces::MailboxHolderPtr, gpu::MailboxHolder>::ConvertFrom(
+MailboxHolderPtr
+TypeConverter<MailboxHolderPtr, gpu::MailboxHolder>::ConvertFrom(
     const gpu::MailboxHolder& input) {
-  surfaces::MailboxHolderPtr holder(surfaces::MailboxHolder::New());
-  holder->mailbox = surfaces::Mailbox::From<gpu::Mailbox>(input.mailbox);
+  MailboxHolderPtr holder(MailboxHolder::New());
+  holder->mailbox = Mailbox::From<gpu::Mailbox>(input.mailbox);
   holder->texture_target = input.texture_target;
   holder->sync_point = input.sync_point;
   return holder.Pass();
@@ -317,8 +313,8 @@ TypeConverter<surfaces::MailboxHolderPtr, gpu::MailboxHolder>::ConvertFrom(
 
 // static
 gpu::MailboxHolder
-TypeConverter<surfaces::MailboxHolderPtr, gpu::MailboxHolder>::ConvertTo(
-    const surfaces::MailboxHolderPtr& input) {
+TypeConverter<MailboxHolderPtr, gpu::MailboxHolder>::ConvertTo(
+    const MailboxHolderPtr& input) {
   gpu::MailboxHolder holder;
   holder.mailbox = input->mailbox.To<gpu::Mailbox>();
   holder.texture_target = input->texture_target;
@@ -327,18 +323,16 @@ TypeConverter<surfaces::MailboxHolderPtr, gpu::MailboxHolder>::ConvertTo(
 }
 
 // static
-surfaces::TransferableResourcePtr TypeConverter<
-    surfaces::TransferableResourcePtr,
+TransferableResourcePtr TypeConverter<
+    TransferableResourcePtr,
     cc::TransferableResource>::ConvertFrom(const cc::TransferableResource&
                                                input) {
-  surfaces::TransferableResourcePtr transferable =
-      surfaces::TransferableResource::New();
+  TransferableResourcePtr transferable = TransferableResource::New();
   transferable->id = input.id;
-  transferable->format = static_cast<surfaces::ResourceFormat>(input.format);
+  transferable->format = static_cast<ResourceFormat>(input.format);
   transferable->filter = input.filter;
   transferable->size = Size::From(input.size);
-  transferable->mailbox_holder =
-      surfaces::MailboxHolder::From(input.mailbox_holder);
+  transferable->mailbox_holder = MailboxHolder::From(input.mailbox_holder);
   transferable->is_repeated = input.is_repeated;
   transferable->is_software = input.is_software;
   return transferable.Pass();
@@ -346,8 +340,8 @@ surfaces::TransferableResourcePtr TypeConverter<
 
 // static
 cc::TransferableResource
-TypeConverter<surfaces::TransferableResourcePtr, cc::TransferableResource>::
-    ConvertTo(const surfaces::TransferableResourcePtr& input) {
+TypeConverter<TransferableResourcePtr, cc::TransferableResource>::
+    ConvertTo(const TransferableResourcePtr& input) {
   cc::TransferableResource transferable;
   transferable.id = input->id;
   transferable.format = static_cast<cc::ResourceFormat>(input->format);
@@ -360,22 +354,22 @@ TypeConverter<surfaces::TransferableResourcePtr, cc::TransferableResource>::
 }
 
 // static
-Array<surfaces::TransferableResourcePtr>
-TypeConverter<Array<surfaces::TransferableResourcePtr>,
+Array<TransferableResourcePtr>
+TypeConverter<Array<TransferableResourcePtr>,
               cc::TransferableResourceArray>::
     ConvertFrom(const cc::TransferableResourceArray& input) {
-  Array<surfaces::TransferableResourcePtr> resources(input.size());
+  Array<TransferableResourcePtr> resources(input.size());
   for (size_t i = 0; i < input.size(); ++i) {
-    resources[i] = surfaces::TransferableResource::From(input[i]);
+    resources[i] = TransferableResource::From(input[i]);
   }
   return resources.Pass();
 }
 
 // static
 cc::TransferableResourceArray
-TypeConverter<Array<surfaces::TransferableResourcePtr>,
+TypeConverter<Array<TransferableResourcePtr>,
               cc::TransferableResourceArray>::
-    ConvertTo(const Array<surfaces::TransferableResourcePtr>& input) {
+    ConvertTo(const Array<TransferableResourcePtr>& input) {
   cc::TransferableResourceArray resources(input.size());
   for (size_t i = 0; i < input.size(); ++i) {
     resources[i] = input[i].To<cc::TransferableResource>();
@@ -384,10 +378,10 @@ TypeConverter<Array<surfaces::TransferableResourcePtr>,
 }
 
 // static
-surfaces::ReturnedResourcePtr
-TypeConverter<surfaces::ReturnedResourcePtr, cc::ReturnedResource>::ConvertFrom(
+ReturnedResourcePtr
+TypeConverter<ReturnedResourcePtr, cc::ReturnedResource>::ConvertFrom(
     const cc::ReturnedResource& input) {
-  surfaces::ReturnedResourcePtr returned = surfaces::ReturnedResource::New();
+  ReturnedResourcePtr returned = ReturnedResource::New();
   returned->id = input.id;
   returned->sync_point = input.sync_point;
   returned->count = input.count;
@@ -397,8 +391,8 @@ TypeConverter<surfaces::ReturnedResourcePtr, cc::ReturnedResource>::ConvertFrom(
 
 // static
 cc::ReturnedResource
-TypeConverter<surfaces::ReturnedResourcePtr, cc::ReturnedResource>::ConvertTo(
-    const surfaces::ReturnedResourcePtr& input) {
+TypeConverter<ReturnedResourcePtr, cc::ReturnedResource>::ConvertTo(
+    const ReturnedResourcePtr& input) {
   cc::ReturnedResource returned;
   returned.id = input->id;
   returned.sync_point = input->sync_point;
@@ -408,36 +402,35 @@ TypeConverter<surfaces::ReturnedResourcePtr, cc::ReturnedResource>::ConvertTo(
 }
 
 // static
-Array<surfaces::ReturnedResourcePtr> TypeConverter<
-    Array<surfaces::ReturnedResourcePtr>,
+Array<ReturnedResourcePtr> TypeConverter<
+    Array<ReturnedResourcePtr>,
     cc::ReturnedResourceArray>::ConvertFrom(const cc::ReturnedResourceArray&
                                                 input) {
-  Array<surfaces::ReturnedResourcePtr> resources(input.size());
+  Array<ReturnedResourcePtr> resources(input.size());
   for (size_t i = 0; i < input.size(); ++i) {
-    resources[i] = surfaces::ReturnedResource::From(input[i]);
+    resources[i] = ReturnedResource::From(input[i]);
   }
   return resources.Pass();
 }
 
 // static
-surfaces::FramePtr
-TypeConverter<surfaces::FramePtr, cc::CompositorFrame>::ConvertFrom(
+FramePtr TypeConverter<FramePtr, cc::CompositorFrame>::ConvertFrom(
     const cc::CompositorFrame& input) {
-  surfaces::FramePtr frame = surfaces::Frame::New();
+  FramePtr frame = 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);
+      Array<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());
+  frame->passes = Array<PassPtr>::New(pass_list.size());
   for (size_t i = 0; i < pass_list.size(); ++i) {
-    frame->passes[i] = surfaces::Pass::From(*pass_list[i]);
+    frame->passes[i] = Pass::From(*pass_list[i]);
   }
   return frame.Pass();
 }
 
 // static
-scoped_ptr<cc::CompositorFrame> ConvertTo(const surfaces::FramePtr& input) {
+scoped_ptr<cc::CompositorFrame> ConvertTo(const FramePtr& input) {
   scoped_ptr<cc::DelegatedFrameData> frame_data(new cc::DelegatedFrameData);
   frame_data->device_scale_factor = 1.f;
   frame_data->resource_list =