Move implementation of WebFilterOperations into cc

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 423 matching lines @@
 
   GLC(Context(), Context()->lineWidth(quad->width));
 
   // The indices for the line are stored in the same array as the triangle
   // indices.
   GLC(Context(),
       Context()->drawElements(GL_LINE_LOOP, 4, GL_UNSIGNED_SHORT, 0));
 }
 
 static inline SkBitmap ApplyFilters(GLRenderer* renderer,
-                                    const WebKit::WebFilterOperations& filters,
+                                    const FilterOperations& filters,
                                     ScopedResource* source_texture_resource) {
-  if (filters.isEmpty())
+  if (filters.IsEmpty())
     return SkBitmap();
 
   ContextProvider* offscreen_contexts =
       renderer->resource_provider()->offscreen_context_provider();
   if (!offscreen_contexts || !offscreen_contexts->GrContext())
     return SkBitmap();
 
   ResourceProvider::ScopedWriteLockGL lock(renderer->resource_provider(),
                                            source_texture_resource->id());
 
@@ skipping 125 matching lines @@
   // the current background pixels with the new filtered background.
   // 6. Draw the contents of the quad over drop of the new background with
   // blending, as per usual. The filtered background pixels will show through
   // any non-opaque pixels in this draws.
   //
   // Pixel copies in this algorithm occur at steps 2, 3, 4, and 5.
 
   // FIXME: When this algorithm changes, update
   // LayerTreeHost::PrioritizeTextures() accordingly.
 
-  const WebKit::WebFilterOperations& filters = quad->background_filters;
-  DCHECK(!filters.isEmpty());
+  const FilterOperations& filters = quad->background_filters;
+  DCHECK(!filters.IsEmpty());
 
   // FIXME: We only allow background filters on an opaque render surface because
   // other surfaces may contain translucent pixels, and the contents behind
   // those translucent pixels wouldn't have the filter applied.
   if (frame->current_render_pass->has_transparent_background)
     return scoped_ptr<ScopedResource>();
   DCHECK(!frame->current_texture);
 
   // FIXME: Do a single readback for both the surface and replica and cache the
   // filtered results (once filter textures are not reused).
   gfx::Rect window_rect = gfx::ToEnclosingRect(MathUtil::MapClippedRect(
       contents_device_transform, SharedGeometryQuad().BoundingBox()));
 
   int top, right, bottom, left;
-  filters.getOutsets(top, right, bottom, left);
+  filters.GetOutsets(&top, &right, &bottom, &left);
   window_rect.Inset(-left, -top, -right, -bottom);
 
   window_rect.Intersect(
       MoveFromDrawToWindowSpace(frame->current_render_pass->output_rect));
 
   scoped_ptr<ScopedResource> device_background_texture =
       ScopedResource::create(resource_provider_);
   if (!device_background_texture->Allocate(window_rect.size(),
                                            GL_RGB,
                                            ResourceProvider::TextureUsageAny)) {
@@ skipping 78 matching lines @@
       frame->window_matrix * frame->projection_matrix * quad_rect_matrix;
   contents_device_transform.FlattenTo2d();
 
   // Can only draw surface if device matrix is invertible.
   gfx::Transform contents_device_transform_inverse(
       gfx::Transform::kSkipInitialization);
   if (!contents_device_transform.GetInverse(&contents_device_transform_inverse))
     return;
 
   scoped_ptr<ScopedResource> background_texture;
-  if (!quad->background_filters.isEmpty()) {
+  if (!quad->background_filters.IsEmpty()) {
     // The pixels from the filtered background should completely replace the
     // current pixel values.
     bool disable_blending = blend_enabled();
     if (disable_blending)
       SetBlendEnabled(false);
 
     background_texture = DrawBackgroundFilters(
         frame,
         quad,
         contents_device_transform,
@@ skipping 2311 matching lines @@
   // The Skia GPU backend requires a stencil buffer.  See ReinitializeGrCanvas
   // implementation.
   return gr_context_ && context_->getContextAttributes().stencil;
 }
 
 bool GLRenderer::IsContextLost() {
   return (context_->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc