cc: Make OverlayCandidate use gfx::BufferFormat instead of cc::ResourceFormat.

cc/output/overlay_candidate.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 "cc/output/overlay_candidate.h"
 
 #include <algorithm>
 #include <limits>
 #include "base/logging.h"
 #include "cc/base/math_util.h"
@@ skipping 155 matching lines @@
       break;
     default:
       return gfx::OVERLAY_TRANSFORM_INVALID;
   }
 }
 
 }  // namespace
 
 OverlayCandidate::OverlayCandidate()
     : transform(gfx::OVERLAY_TRANSFORM_NONE),
-      format(RGBA_8888),
+      format(gfx::BufferFormat::RGBA_8888),
       uv_rect(0.f, 0.f, 1.f, 1.f),
       is_clipped(false),
       use_output_surface_for_resource(false),
       resource_id(0),
 #if defined(OS_ANDROID)
       is_backed_by_surface_texture(false),
       is_promotable_hint(false),
 #endif
       plane_z_order(0),
       is_unoccluded(false),
@@ skipping 12 matching lines @@
       quad->shared_quad_state->opacity != 1.f ||
       quad->shared_quad_state->blend_mode != SkBlendMode::kSrcOver)
     return false;
 
   auto& transform = quad->shared_quad_state->quad_to_target_transform;
   candidate->display_rect = gfx::RectF(quad->rect);
   transform.TransformRect(&candidate->display_rect);
   candidate->quad_rect_in_target_space =
       MathUtil::MapEnclosingClippedRect(transform, quad->rect);
 
-  candidate->format = RGBA_8888;
   candidate->clip_rect = quad->shared_quad_state->clip_rect;
   candidate->is_clipped = quad->shared_quad_state->is_clipped;
 
   switch (quad->material) {
     case DrawQuad::TEXTURE_CONTENT:
       return FromTextureQuad(resource_provider,
                              TextureDrawQuad::MaterialCast(quad), candidate);
     case DrawQuad::STREAM_VIDEO_CONTENT:
       return FromStreamVideoQuad(resource_provider,
                                  StreamVideoDrawQuad::MaterialCast(quad),
@@ skipping 35 matching lines @@
   }
   return false;
 }
 
 // static
 bool OverlayCandidate::FromTextureQuad(ResourceProvider* resource_provider,
                                        const TextureDrawQuad* quad,
                                        OverlayCandidate* candidate) {
   if (!resource_provider->IsOverlayCandidate(quad->resource_id()))
     return false;
-
-  gfx::BufferFormat format =
-      resource_provider->GetBufferFormat(quad->resource_id());
+  candidate->format = resource_provider->GetBufferFormat(quad->resource_id());
   if (std::find(std::begin(kOverlayFormats), std::end(kOverlayFormats),
-                format) == std::end(kOverlayFormats))
+                candidate->format) == std::end(kOverlayFormats))
     return false;
   gfx::OverlayTransform overlay_transform = GetOverlayTransform(
       quad->shared_quad_state->quad_to_target_transform, quad->y_flipped);
   if (quad->background_color != SK_ColorTRANSPARENT ||
       overlay_transform == gfx::OVERLAY_TRANSFORM_INVALID)
     return false;
   candidate->resource_id = quad->resource_id();
   candidate->resource_size_in_pixels = quad->resource_size_in_pixels();
   candidate->transform = overlay_transform;
   candidate->uv_rect = BoundingRect(quad->uv_top_left, quad->uv_bottom_right);
@@ skipping 65 matching lines @@
 
 OverlayCandidateList& OverlayCandidateList::operator=(
     OverlayCandidateList&& other) = default;
 
 void OverlayCandidateList::AddPromotionHint(const OverlayCandidate& candidate) {
   promotion_hint_info_map_[candidate.resource_id] =
       candidate.display_rect.origin();
 }
 
 }  // namespace cc