Revert of Revert "compositor: Fix texture flipping for SW mirroring with surfaceless"

content/browser/compositor/reflector_impl.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 "content/browser/compositor/reflector_impl.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "content/browser/compositor/browser_compositor_output_surface.h"
 #include "content/browser/compositor/owned_mailbox.h"
@@ skipping 20 matching lines @@
       FROM_HERE,
       base::Bind(
           &ReflectorImpl::InitOnImplThread, this, main.mailbox->holder()));
 }
 
 ReflectorImpl::MainThreadData::MainThreadData(
     ui::Compositor* mirrored_compositor,
     ui::Layer* mirroring_layer)
     : needs_set_mailbox(true),
       mirrored_compositor(mirrored_compositor),
-      mirroring_layer(mirroring_layer) {}
+      mirroring_layer(mirroring_layer),
+      flip_texture(false) {
+}
 
 ReflectorImpl::MainThreadData::~MainThreadData() {}
 
 ReflectorImpl::ImplThreadData::ImplThreadData(
     IDMap<BrowserCompositorOutputSurface>* output_surface_map)
     : output_surface_map(output_surface_map),
       output_surface(NULL),
       texture_id(0) {}
 
 ReflectorImpl::ImplThreadData::~ImplThreadData() {}
@@ skipping 134 matching lines @@
   output_surface->context_provider()->BindToCurrentThread();
   impl.gl_helper.reset(
       new GLHelper(output_surface->context_provider()->ContextGL(),
                    output_surface->context_provider()->ContextSupport()));
   impl.texture_id = impl.gl_helper->ConsumeMailboxToTexture(
       mailbox_holder.mailbox, mailbox_holder.sync_point);
   impl.gl_helper->ResizeTexture(impl.texture_id, output_surface->SurfaceSize());
   impl.gl_helper->Flush();
   output_surface->SetReflector(this);
   // The texture doesn't have the data, so invokes full redraw now.
+  bool flip_texture = !output_surface->capabilities().flipped_output_surface;
   main_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&ReflectorImpl::FullRedrawContentOnMainThread,
-                 scoped_refptr<ReflectorImpl>(this)));
+      FROM_HERE, base::Bind(&ReflectorImpl::FullRedrawContentOnMainThread,
+                            scoped_refptr<ReflectorImpl>(this), flip_texture));
 }
 
 void ReflectorImpl::UpdateTextureSizeOnMainThread(gfx::Size size) {
   MainThreadData& main = GetMain();
   if (!main.mirroring_layer || !main.mailbox.get() ||
       main.mailbox->mailbox().IsZero())
     return;
   if (main.needs_set_mailbox) {
     main.mirroring_layer->SetTextureMailbox(
         cc::TextureMailbox(main.mailbox->holder()),
         cc::SingleReleaseCallback::Create(
             base::Bind(ReleaseMailbox, main.mailbox)),
         size);
     main.needs_set_mailbox = false;
   } else {
     main.mirroring_layer->SetTextureSize(size);
   }
   main.mirroring_layer->SetBounds(gfx::Rect(size));
+  main.mirroring_layer->SetTextureFlipped(main.flip_texture);
 }
 
 void ReflectorImpl::FullRedrawOnMainThread(gfx::Size size) {
   MainThreadData& main = GetMain();
   if (!main.mirroring_layer)
     return;
   UpdateTextureSizeOnMainThread(size);
   main.mirroring_layer->SchedulePaint(main.mirroring_layer->bounds());
 }
 
-void ReflectorImpl::UpdateSubBufferOnMainThread(gfx::Size size,
-                                                gfx::Rect rect) {
+void ReflectorImpl::UpdateSubBufferOnMainThread(const gfx::Size& size,
+                                                const gfx::Rect& rect) {
   MainThreadData& main = GetMain();
   if (!main.mirroring_layer)
     return;
   UpdateTextureSizeOnMainThread(size);
+
+  int y = rect.y();
   // Flip the coordinates to compositor's one.
-  int y = size.height() - rect.y() - rect.height();
+  if (main.flip_texture)
+    y = size.height() - rect.y() - rect.height();
   gfx::Rect new_rect(rect.x(), y, rect.width(), rect.height());
   main.mirroring_layer->SchedulePaint(new_rect);
 }
 
-void ReflectorImpl::FullRedrawContentOnMainThread() {
+void ReflectorImpl::FullRedrawContentOnMainThread(bool flip_texture) {
   MainThreadData& main = GetMain();
+  main.flip_texture = flip_texture;
   main.mirrored_compositor->ScheduleFullRedraw();
 }
 
 }  // namespace content