Fix content upside down when call OffscreenCanvas's commit

third_party/WebKit/Source/platform/graphics/OffscreenCanvasFrameDispatcherImpl.cpp

 // Copyright 2016 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 "platform/graphics/OffscreenCanvasFrameDispatcherImpl.h"
 
 #include "cc/output/compositor_frame.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/shared_quad_state.h"
@@ skipping 165 matching lines @@
   cc::TransferableResource resource;
   resource.id = m_nextResourceId;
   resource.format = cc::ResourceFormat::RGBA_8888;
   // TODO(crbug.com/645590): filter should respect the image-rendering CSS
   // property of associated canvas element.
   resource.filter = GL_LINEAR;
   resource.size = gfx::Size(m_width, m_height);
   // TODO(crbug.com/646022): making this overlay-able.
   resource.is_overlay_candidate = false;
 
+  bool yflipped = false;
   OffscreenCanvasCommitType commitType;
   DEFINE_THREAD_SAFE_STATIC_LOCAL(
       EnumerationHistogram, commitTypeHistogram,
       new EnumerationHistogram("OffscreenCanvas.CommitType",
                                OffscreenCanvasCommitTypeCount));
   if (image->isTextureBacked()) {
     if (Platform::current()->isGPUCompositingEnabled() &&
         !isWebGLSoftwareRendering) {
       // Case 1: both canvas and compositor are gpu accelerated.
       commitType = CommitGPUCanvasGPUCompositing;
       setTransferableResourceToStaticBitmapImage(resource, image);
+      yflipped = true;
     } else {
       // Case 2: canvas is accelerated but --disable-gpu-compositing is
       // specified, or WebGL's commit is called with SwiftShader. The latter
       // case is indicated by
       // WebGraphicsContext3DProvider::isSoftwareRendering.
       commitType = CommitGPUCanvasSoftwareCompositing;
       setTransferableResourceToSharedBitmap(resource, image);
     }
   } else {
     if (Platform::current()->isGPUCompositingEnabled() &&
         !isWebGLSoftwareRendering) {
       // Case 3: canvas is not gpu-accelerated, but compositor is
       commitType = CommitSoftwareCanvasGPUCompositing;
       setTransferableResourceToSharedGPUContext(resource, image);
+      yflipped = true;
     } else {
       // Case 4: both canvas and compositor are not gpu accelerated.
       commitType = CommitSoftwareCanvasSoftwareCompositing;
       setTransferableResourceToSharedBitmap(resource, image);
     }
   }
   commitTypeHistogram.count(commitType);
 
   m_nextResourceId++;
   frame.delegated_frame_data->resource_list.push_back(std::move(resource));
 
   cc::TextureDrawQuad* quad =
       pass->CreateAndAppendDrawQuad<cc::TextureDrawQuad>();
   gfx::Size rectSize(m_width, m_height);
 
   const bool needsBlending = true;
   // TOOD(crbug.com/645993): this should be inherited from WebGL context's
   // creation settings.
   const bool premultipliedAlpha = true;
   const gfx::PointF uvTopLeft(0.f, 0.f);
   const gfx::PointF uvBottomRight(1.f, 1.f);
   float vertexOpacity[4] = {1.f, 1.f, 1.f, 1.f};
-  const bool yflipped = false;
   // TODO(crbug.com/645994): this should be true when using style
   // "image-rendering: pixelated".
   const bool nearestNeighbor = false;
   quad->SetAll(sqs, bounds, bounds, bounds, needsBlending, resource.id,
                gfx::Size(), premultipliedAlpha, uvTopLeft, uvBottomRight,
                SK_ColorTRANSPARENT, vertexOpacity, yflipped, nearestNeighbor,
                false);
 
   frame.delegated_frame_data->render_pass_list.push_back(std::move(pass));
 
@@ skipping 84 matching lines @@
 }
 
 bool OffscreenCanvasFrameDispatcherImpl::verifyImageSize(
     const sk_sp<SkImage>& image) {
   if (image && image->width() == m_width && image->height() == m_height)
     return true;
   return false;
 }
 
 }  // namespace blink