Update from chromium https://crrev.com/301725/

cc/output/direct_renderer.cc

 // Copyright 2012 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/output/direct_renderer.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
@@ skipping 64 matching lines @@
   *quad_rect_transform = quad_transform;
   quad_rect_transform->Translate(0.5 * quad_rect.width() + quad_rect.x(),
                                  0.5 * quad_rect.height() + quad_rect.y());
   quad_rect_transform->Scale(quad_rect.width(), quad_rect.height());
 }
 
 void DirectRenderer::InitializeViewport(DrawingFrame* frame,
                                         const gfx::Rect& draw_rect,
                                         const gfx::Rect& viewport_rect,
                                         const gfx::Size& surface_size) {
-  bool flip_y = FlippedFramebuffer();
-
   DCHECK_GE(viewport_rect.x(), 0);
   DCHECK_GE(viewport_rect.y(), 0);
   DCHECK_LE(viewport_rect.right(), surface_size.width());
   DCHECK_LE(viewport_rect.bottom(), surface_size.height());
+  bool flip_y = FlippedFramebuffer(frame);
   if (flip_y) {
     frame->projection_matrix = OrthoProjectionMatrix(draw_rect.x(),
                                                      draw_rect.right(),
                                                      draw_rect.bottom(),
                                                      draw_rect.y());
   } else {
     frame->projection_matrix = OrthoProjectionMatrix(draw_rect.x(),
                                                      draw_rect.right(),
                                                      draw_rect.y(),
                                                      draw_rect.bottom());
   }
 
   gfx::Rect window_rect = viewport_rect;
   if (flip_y)
     window_rect.set_y(surface_size.height() - viewport_rect.bottom());
   frame->window_matrix = window_matrix(window_rect.x(),
                                        window_rect.y(),
                                        window_rect.width(),
                                        window_rect.height());
   SetDrawViewport(window_rect);
 
   current_draw_rect_ = draw_rect;
   current_viewport_rect_ = viewport_rect;
   current_surface_size_ = surface_size;
 }
 
 gfx::Rect DirectRenderer::MoveFromDrawToWindowSpace(
+    const DrawingFrame* frame,
     const gfx::Rect& draw_rect) const {
   gfx::Rect window_rect = draw_rect;
   window_rect -= current_draw_rect_.OffsetFromOrigin();
   window_rect += current_viewport_rect_.OffsetFromOrigin();
-  if (FlippedFramebuffer())
+  if (FlippedFramebuffer(frame))
     window_rect.set_y(current_surface_size_.height() - window_rect.bottom());
   return window_rect;
 }
 
 DirectRenderer::DirectRenderer(RendererClient* client,
                                const LayerTreeSettings* settings,
                                OutputSurface* output_surface,
                                ResourceProvider* resource_provider)
     : Renderer(client, settings),
       output_surface_(output_surface),
@@ skipping 139 matching lines @@
 bool DirectRenderer::NeedDeviceClip(const DrawingFrame* frame) const {
   if (frame->current_render_pass != frame->root_render_pass)
     return false;
 
   return !frame->device_clip_rect.Contains(frame->device_viewport_rect);
 }
 
 gfx::Rect DirectRenderer::DeviceClipRectInWindowSpace(const DrawingFrame* frame)
     const {
   gfx::Rect device_clip_rect = frame->device_clip_rect;
-  if (FlippedFramebuffer())
+  if (FlippedFramebuffer(frame))
     device_clip_rect.set_y(current_surface_size_.height() -
                            device_clip_rect.bottom());
   return device_clip_rect;
 }
 
 void DirectRenderer::SetScissorStateForQuad(const DrawingFrame* frame,
                                             const DrawQuad& quad) {
   if (quad.isClipped()) {
     SetScissorTestRectInDrawSpace(frame, quad.clipRect());
     return;
@@ skipping 21 matching lines @@
     return;
   }
 
   *should_skip_quad = false;
   SetScissorTestRectInDrawSpace(frame, quad_scissor_rect);
 }
 
 void DirectRenderer::SetScissorTestRectInDrawSpace(
     const DrawingFrame* frame,
     const gfx::Rect& draw_space_rect) {
-  gfx::Rect window_space_rect = MoveFromDrawToWindowSpace(draw_space_rect);
+  gfx::Rect window_space_rect =
+      MoveFromDrawToWindowSpace(frame, draw_space_rect);
   if (NeedDeviceClip(frame))
     window_space_rect.Intersect(DeviceClipRectInWindowSpace(frame));
   SetScissorTestRect(window_space_rect);
 }
 
 void DirectRenderer::FinishDrawingQuadList() {}
 
 void DirectRenderer::DrawRenderPass(DrawingFrame* frame,
                                     const RenderPass* render_pass) {
   TRACE_EVENT0("cc", "DirectRenderer::DrawRenderPass");
@@ skipping 84 matching lines @@
   ScopedResource* texture = render_pass_textures_.get(id);
   return texture && texture->id();
 }
 
 // static
 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
   return render_pass->output_rect.size();
 }
 
 }  // namespace cc