Mandoline: Fix OOPIF high DPI sizing.

mojo/converters/surfaces/surfaces_type_converters.cc

 // 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/converters/surfaces/surfaces_type_converters.h"
 
 #include "base/macros.h"
 #include "cc/output/compositor_frame.h"
+#include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.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 "cc/quads/tile_draw_quad.h"
@@ skipping 37 matching lines @@
                 input->quad_layer_bounds.To<gfx::Size>(),
                 input->visible_quad_layer_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;
 }
 
 bool ConvertDrawQuad(const QuadPtr& input,
+                     const CompositorFrameMetadataPtr& metadata,
                      cc::SharedQuadState* sqs,
                      cc::RenderPass* render_pass,
                      CustomSurfaceConverter* custom_converter) {
   switch (input->material) {
     case MATERIAL_DEBUG_BORDER: {
       cc::DebugBorderDrawQuad* debug_border_quad =
           render_pass->CreateAndAppendDrawQuad<cc::DebugBorderDrawQuad>();
       debug_border_quad->SetAll(
           sqs,
           input->rect.To<gfx::Rect>(),
@@ skipping 41 matching lines @@
           input->needs_blending,
           input->solid_color_quad_state->color.To<SkColor>(),
           input->solid_color_quad_state->force_anti_aliasing_off);
       break;
     }
     case MATERIAL_SURFACE_CONTENT: {
       if (input->surface_quad_state.is_null())
         return false;
 
       if (custom_converter) {
-        return custom_converter->ConvertSurfaceDrawQuad(input,
-                                                        sqs,
+        return custom_converter->ConvertSurfaceDrawQuad(input, metadata, sqs,
                                                         render_pass);
       }
       cc::SurfaceDrawQuad* surface_quad =
           render_pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
       surface_quad->SetAll(
           sqs,
           input->rect.To<gfx::Rect>(),
           input->opaque_rect.To<gfx::Rect>(),
           input->visible_rect.To<gfx::Rect>(),
           input->needs_blending,
@@ skipping 281 matching lines @@
   // We should copy all shared quad states.
   DCHECK_EQ(next_sqs_iter.index(), shared_quad_state.size());
   pass->quads = quads.Pass();
   pass->shared_quad_states = shared_quad_state.Pass();
   return pass.Pass();
 }
 
 // static
 scoped_ptr<cc::RenderPass> ConvertToRenderPass(
     const mojo::PassPtr& input,
+    const mojo::CompositorFrameMetadataPtr& metadata,
     CustomSurfaceConverter* custom_converter) {
   scoped_ptr<cc::RenderPass> pass = cc::RenderPass::Create(
       input->shared_quad_states.size(), input->quads.size());
   pass->SetAll(input->id.To<cc::RenderPassId>(),
                input->output_rect.To<gfx::Rect>(),
                input->damage_rect.To<gfx::Rect>(),
                input->transform_to_root_target.To<gfx::Transform>(),
                input->has_transparent_background);
   for (size_t i = 0; i < input->shared_quad_states.size(); ++i) {
     ConvertSharedQuadState(input->shared_quad_states[i], pass.get());
   }
   cc::SharedQuadStateList::Iterator sqs_iter =
       pass->shared_quad_state_list.begin();
   for (size_t i = 0; i < input->quads.size(); ++i) {
     QuadPtr quad = input->quads[i].Pass();
     while (quad->shared_quad_state_index > sqs_iter.index()) {
       ++sqs_iter;
     }
-    if (!ConvertDrawQuad(quad, *sqs_iter, pass.get(), custom_converter))
+    if (!ConvertDrawQuad(quad, metadata, *sqs_iter, pass.get(),
+                         custom_converter))
       return scoped_ptr<cc::RenderPass>();
   }
   return pass.Pass();
 }
 
 // static
 scoped_ptr<cc::RenderPass>
 TypeConverter<scoped_ptr<cc::RenderPass>, PassPtr>::Convert(
     const PassPtr& input) {
-  return ConvertToRenderPass(input, nullptr /* CustomSurfaceConverter */);
+  mojo::CompositorFrameMetadataPtr metadata;
+  return ConvertToRenderPass(input, metadata,
+                             nullptr /* CustomSurfaceConverter */);
 }
 
 // static
 MailboxPtr TypeConverter<MailboxPtr, gpu::Mailbox>::Convert(
     const gpu::Mailbox& input) {
   Array<int8_t> name(64);
   for (int i = 0; i < 64; ++i) {
     name[i] = input.name[i];
   }
   MailboxPtr mailbox(Mailbox::New());
@@ skipping 123 matching lines @@
 TypeConverter<cc::ReturnedResourceArray, Array<ReturnedResourcePtr>>::Convert(
     const Array<ReturnedResourcePtr>& input) {
   cc::ReturnedResourceArray resources(input.size());
   for (size_t i = 0; i < input.size(); ++i) {
     resources[i] = input[i].To<cc::ReturnedResource>();
   }
   return resources;
 }
 
 // static
+CompositorFrameMetadataPtr
+TypeConverter<CompositorFrameMetadataPtr, cc::CompositorFrameMetadata>::Convert(
+    const cc::CompositorFrameMetadata& input) {
+  CompositorFrameMetadataPtr metadata = CompositorFrameMetadata::New();
+  metadata->device_scale_factor = input.device_scale_factor;
+  return metadata.Pass();
+}
+
+// static
+cc::CompositorFrameMetadata
+TypeConverter<cc::CompositorFrameMetadata, CompositorFrameMetadataPtr>::Convert(
+    const CompositorFrameMetadataPtr& input) {
+  cc::CompositorFrameMetadata metadata;
+  metadata.device_scale_factor = input->device_scale_factor;
+  return metadata;
+}
+
+// static
 CompositorFramePtr
 TypeConverter<CompositorFramePtr, cc::CompositorFrame>::Convert(
     const cc::CompositorFrame& input) {
   CompositorFramePtr frame = CompositorFrame::New();
   DCHECK(input.delegated_frame_data);
   cc::DelegatedFrameData* frame_data = input.delegated_frame_data.get();
   frame->resources =
       Array<TransferableResourcePtr>::From(frame_data->resource_list);
+  frame->metadata = CompositorFrameMetadata::From(input.metadata);
   const cc::RenderPassList& pass_list = frame_data->render_pass_list;
   frame->passes = Array<PassPtr>::New(pass_list.size());
   for (size_t i = 0; i < pass_list.size(); ++i) {
     frame->passes[i] = Pass::From(*pass_list[i]);
   }
   return frame.Pass();
 }
 
 // static
 scoped_ptr<cc::CompositorFrame> ConvertToCompositorFrame(
     const mojo::CompositorFramePtr& input,
     CustomSurfaceConverter* custom_converter) {
   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) {
-    scoped_ptr<cc::RenderPass> pass =
-        ConvertToRenderPass(input->passes[i], custom_converter);
+    scoped_ptr<cc::RenderPass> pass = ConvertToRenderPass(
+        input->passes[i], input->metadata, custom_converter);
     if (!pass)
       return scoped_ptr<cc::CompositorFrame>();
     frame_data->render_pass_list.push_back(pass.Pass());
   }
   scoped_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
+  cc::CompositorFrameMetadata metadata =
+      input->metadata.To<cc::CompositorFrameMetadata>();
   frame->delegated_frame_data = frame_data.Pass();
   return frame.Pass();
 }
 
 // static
 scoped_ptr<cc::CompositorFrame>
 TypeConverter<scoped_ptr<cc::CompositorFrame>, CompositorFramePtr>::Convert(
     const CompositorFramePtr& input) {
   return ConvertToCompositorFrame(input, nullptr);
 }
 
 }  // namespace mojo