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

cc/output/gl_renderer.cc

 // Copyright 2010 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/gl_renderer.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 355 matching lines @@
   capabilities_.allow_partial_texture_updates = true;
 
   capabilities_.using_image = context_caps.gpu.image;
 
   capabilities_.using_discard_framebuffer =
       context_caps.gpu.discard_framebuffer;
 
   capabilities_.allow_rasterize_on_demand = true;
 
   use_sync_query_ = context_caps.gpu.sync_query;
-  use_blend_minmax_ = context_caps.gpu.blend_minmax;
   use_blend_equation_advanced_ = context_caps.gpu.blend_equation_advanced;
   use_blend_equation_advanced_coherent_ =
       context_caps.gpu.blend_equation_advanced_coherent;
 
   InitializeSharedObjects();
 }
 
 GLRenderer::~GLRenderer() {
   while (!pending_async_read_pixels_.empty()) {
     PendingAsyncReadPixels* pending_read = pending_async_read_pixels_.back();
@@ skipping 344 matching lines @@
   // Flush the GrContext to ensure all buffered GL calls are drawn to the
   // backing store before we access and return it, and have cc begin using the
   // GL context again.
   canvas->flush();
 
   return image;
 }
 
 bool GLRenderer::CanApplyBlendModeUsingBlendFunc(SkXfermode::Mode blend_mode) {
   return use_blend_equation_advanced_ ||
-         (use_blend_minmax_ && blend_mode == SkXfermode::kLighten_Mode) ||
          blend_mode == SkXfermode::kScreen_Mode ||
          blend_mode == SkXfermode::kSrcOver_Mode;
 }
 
 void GLRenderer::ApplyBlendModeUsingBlendFunc(SkXfermode::Mode blend_mode) {
   DCHECK(CanApplyBlendModeUsingBlendFunc(blend_mode));
 
   // Any modes set here must be reset in RestoreBlendFuncToDefault
   if (use_blend_equation_advanced_) {
     GLenum equation = GL_FUNC_ADD;
@@ skipping 45 matching lines @@
         equation = GL_HSL_LUMINOSITY_KHR;
         break;
       default:
         return;
     }
 
     GLC(gl_, gl_->BlendEquation(equation));
   } else {
     if (blend_mode == SkXfermode::kScreen_Mode) {
       GLC(gl_, gl_->BlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ONE));
-    } else if (blend_mode == SkXfermode::kLighten_Mode) {
-      GLC(gl_, gl_->BlendFunc(GL_ONE, GL_ONE));
-      GLC(gl_, gl_->BlendEquation(GL_MAX_EXT));
     }
   }
 }
 
 void GLRenderer::RestoreBlendFuncToDefault(SkXfermode::Mode blend_mode) {
   if (blend_mode == SkXfermode::kSrcOver_Mode)
     return;
 
   if (use_blend_equation_advanced_) {
     GLC(gl_, gl_->BlendEquation(GL_FUNC_ADD));
   } else {
     GLC(gl_, gl_->BlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
-
-    if (blend_mode == SkXfermode::kLighten_Mode)
-      GLC(gl_, gl_->BlendEquation(GL_FUNC_ADD));
   }
 }
 
 bool GLRenderer::ShouldApplyBackgroundFilters(DrawingFrame* frame,
                                               const RenderPassDrawQuad* quad) {
   if (quad->background_filters.IsEmpty())
     return false;
 
   // TODO(danakj): We only allow background filters on an opaque render surface
   // because other surfaces may contain translucent pixels, and the contents
@@ skipping 20 matching lines @@
     int top, right, bottom, left;
     quad->background_filters.GetOutsets(&top, &right, &bottom, &left);
     backdrop_rect.Inset(-left, -top, -right, -bottom);
   }
 
   if (!backdrop_rect.IsEmpty() && use_aa) {
     const int kOutsetForAntialiasing = 1;
     backdrop_rect.Inset(-kOutsetForAntialiasing, -kOutsetForAntialiasing);
   }
 
-  backdrop_rect.Intersect(
-      MoveFromDrawToWindowSpace(frame->current_render_pass->output_rect));
+  backdrop_rect.Intersect(MoveFromDrawToWindowSpace(
+      frame, frame->current_render_pass->output_rect));
   return backdrop_rect;
 }
 
 scoped_ptr<ScopedResource> GLRenderer::GetBackdropTexture(
     const gfx::Rect& bounding_rect) {
   scoped_ptr<ScopedResource> device_background_texture =
       ScopedResource::Create(resource_provider_);
   // CopyTexImage2D fails when called on a texture having immutable storage.
   device_background_texture->Allocate(
       bounding_rect.size(), ResourceProvider::TextureHintDefault, RGBA_8888);
@@ skipping 1154 matching lines @@
     on_demand_tile_raster_resource_id_ = resource_provider_->CreateGLTexture(
         quad->texture_size,
         GL_TEXTURE_2D,
         GL_TEXTURE_POOL_UNMANAGED_CHROMIUM,
         GL_CLAMP_TO_EDGE,
         ResourceProvider::TextureHintImmutable,
         quad->texture_format);
   }
 
   SkCanvas canvas(on_demand_tile_raster_bitmap_);
-  quad->picture_pile->RasterToBitmap(
+  quad->picture_pile->PlaybackToCanvas(
       &canvas, quad->content_rect, quad->contents_scale, NULL);
 
   uint8_t* bitmap_pixels = NULL;
   SkBitmap on_demand_tile_raster_bitmap_dest;
   SkColorType colorType = ResourceFormatToSkColorType(quad->texture_format);
   if (on_demand_tile_raster_bitmap_.colorType() != colorType) {
     on_demand_tile_raster_bitmap_.copyTo(&on_demand_tile_raster_bitmap_dest,
                                          colorType);
     // TODO(kaanb): The GL pipeline assumes a 4-byte alignment for the
     // bitmap data. This check will be removed once crbug.com/293728 is fixed.
@@ skipping 228 matching lines @@
   swap_buffer_rect_.Union(gfx::ToEnclosingRect(frame->root_damage_rect));
 
   GLC(gl_, gl_->Disable(GL_BLEND));
   blend_shadow_ = false;
 
   ScheduleOverlays(frame);
 }
 
 void GLRenderer::FinishDrawingQuadList() { FlushTextureQuadCache(); }
 
-bool GLRenderer::FlippedFramebuffer() const { return true; }
+bool GLRenderer::FlippedFramebuffer(const DrawingFrame* frame) const {
+  if (frame->current_render_pass != frame->root_render_pass)
+    return true;
+  return FlippedRootFramebuffer();
+}
+
+bool GLRenderer::FlippedRootFramebuffer() const {
+  // GL is normally flipped, so a flipped output results in an unflipping.
+  return !output_surface_->capabilities().flipped_output_surface;
+}
 
 void GLRenderer::EnsureScissorTestEnabled() {
   if (is_scissor_enabled_)
     return;
 
   FlushTextureQuadCache();
   GLC(gl_, gl_->Enable(GL_SCISSOR_TEST));
   is_scissor_enabled_ = true;
 }
 
 void GLRenderer::EnsureScissorTestDisabled() {
   if (!is_scissor_enabled_)
     return;
 
   FlushTextureQuadCache();
   GLC(gl_, gl_->Disable(GL_SCISSOR_TEST));
   is_scissor_enabled_ = false;
 }
 
 void GLRenderer::CopyCurrentRenderPassToBitmap(
     DrawingFrame* frame,
     scoped_ptr<CopyOutputRequest> request) {
   TRACE_EVENT0("cc", "GLRenderer::CopyCurrentRenderPassToBitmap");
   gfx::Rect copy_rect = frame->current_render_pass->output_rect;
   if (request->has_area())
     copy_rect.Intersect(request->area());
-  GetFramebufferPixelsAsync(copy_rect, request.Pass());
+  GetFramebufferPixelsAsync(frame, copy_rect, request.Pass());
 }
 
 void GLRenderer::ToGLMatrix(float* gl_matrix, const gfx::Transform& transform) {
   transform.matrix().asColMajorf(gl_matrix);
 }
 
 void GLRenderer::SetShaderQuadF(const gfx::QuadF& quad, int quad_location) {
   if (quad_location == -1)
     return;
 
@@ skipping 112 matching lines @@
   compositor_frame.gl_frame_data->size = surface_size;
   if (capabilities_.using_partial_swap) {
     // If supported, we can save significant bandwidth by only swapping the
     // damaged/scissored region (clamped to the viewport).
     swap_buffer_rect_.Intersect(gfx::Rect(surface_size));
     int flipped_y_pos_of_rect_bottom = surface_size.height() -
                                        swap_buffer_rect_.y() -
                                        swap_buffer_rect_.height();
     compositor_frame.gl_frame_data->sub_buffer_rect =
         gfx::Rect(swap_buffer_rect_.x(),
-                  flipped_y_pos_of_rect_bottom,
+                  FlippedRootFramebuffer() ? flipped_y_pos_of_rect_bottom
+                                           : swap_buffer_rect_.y(),
                   swap_buffer_rect_.width(),
                   swap_buffer_rect_.height());
   } else {
     compositor_frame.gl_frame_data->sub_buffer_rect =
         gfx::Rect(output_surface_->SurfaceSize());
   }
   output_surface_->SwapBuffers(&compositor_frame);
 
   // Release previously used overlay resources and hold onto the pending ones
   // until the next swap buffers.
@@ skipping 28 matching lines @@
 
 void GLRenderer::EnsureBackbuffer() {
   if (!is_backbuffer_discarded_)
     return;
 
   output_surface_->EnsureBackbuffer();
   is_backbuffer_discarded_ = false;
 }
 
 void GLRenderer::GetFramebufferPixelsAsync(
+    const DrawingFrame* frame,
     const gfx::Rect& rect,
     scoped_ptr<CopyOutputRequest> request) {
   DCHECK(!request->IsEmpty());
   if (request->IsEmpty())
     return;
   if (rect.IsEmpty())
     return;
 
-  gfx::Rect window_rect = MoveFromDrawToWindowSpace(rect);
+  gfx::Rect window_rect = MoveFromDrawToWindowSpace(frame, rect);
   DCHECK_GE(window_rect.x(), 0);
   DCHECK_GE(window_rect.y(), 0);
   DCHECK_LE(window_rect.right(), current_surface_size_.width());
   DCHECK_LE(window_rect.bottom(), current_surface_size_.height());
 
   if (!request->force_bitmap_result()) {
     bool own_mailbox = !request->has_texture_mailbox();
 
     GLuint texture_id = 0;
     gpu::Mailbox mailbox;
@@ skipping 839 matching lines @@
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order,
         overlay.transform,
         pending_overlay_resources_.back()->texture_id(),
         overlay.display_rect,
         overlay.uv_rect);
   }
 }
 
 }  // namespace cc