Update from https://crrev.com/316786

cc/layers/tiled_layer_impl.cc

 // Copyright 2011 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/layers/tiled_layer_impl.h"
 
 #include "base/basictypes.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/base/math_util.h"
@@ skipping 95 matching lines @@
                                               float* width) const {
   *color = DebugColors::TiledContentLayerBorderColor();
   *width = DebugColors::TiledContentLayerBorderWidth(layer_tree_impl());
 }
 
 scoped_ptr<LayerImpl> TiledLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
   return TiledLayerImpl::Create(tree_impl, id(), synced_scroll_offset());
 }
 
-void TiledLayerImpl::AsValueInto(base::debug::TracedValue* state) const {
+void TiledLayerImpl::AsValueInto(base::trace_event::TracedValue* state) const {
   LayerImpl::AsValueInto(state);
   MathUtil::AddToTracedValue("invalidation", update_rect(), state);
 }
 
 size_t TiledLayerImpl::GPUMemoryUsageInBytes() const {
   size_t amount = 0;
   const size_t kMemoryUsagePerTileInBytes =
       4 * tiler_->tile_size().width() * tiler_->tile_size().height();
   for (LayerTilingData::TileMap::const_iterator iter = tiler_->tiles().begin();
        iter != tiler_->tiles().end();
@@ skipping 32 matching lines @@
 bool TiledLayerImpl::WillDraw(DrawMode draw_mode,
                               ResourceProvider* resource_provider) {
   if (!tiler_ || tiler_->has_empty_bounds() ||
       visible_content_rect().IsEmpty() ||
       draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE)
     return false;
   return LayerImpl::WillDraw(draw_mode, resource_provider);
 }
 
 void TiledLayerImpl::AppendQuads(RenderPass* render_pass,
-                                 const Occlusion& occlusion_in_content_space,
                                  AppendQuadsData* append_quads_data) {
   DCHECK(tiler_);
   DCHECK(!tiler_->has_empty_bounds());
   DCHECK(!visible_content_rect().IsEmpty());
 
   gfx::Rect content_rect = visible_content_rect();
   SharedQuadState* shared_quad_state =
       render_pass->CreateAndAppendSharedQuadState();
   PopulateSharedQuadState(shared_quad_state);
 
@@ skipping 38 matching lines @@
       DrawableTile* tile = TileAt(i, j);
       gfx::Rect tile_rect = tiler_->tile_bounds(i, j);
       gfx::Rect display_rect = tile_rect;
       tile_rect.Intersect(content_rect);
 
       // Skip empty tiles.
       if (tile_rect.IsEmpty())
         continue;
 
       gfx::Rect visible_tile_rect =
-          occlusion_in_content_space.GetUnoccludedContentRect(tile_rect);
+          draw_properties().occlusion_in_content_space.GetUnoccludedContentRect(
+              tile_rect);
       if (visible_tile_rect.IsEmpty())
         continue;
 
       if (!tile || !tile->resource_id()) {
         SkColor checker_color;
         if (ShowDebugBorders()) {
           checker_color =
               tile ? DebugColors::InvalidatedTileCheckerboardColor()
                    : DebugColors::EvictedTileCheckerboardColor();
         } else {
@@ skipping 75 matching lines @@
 
 void TiledLayerImpl::ReleaseResources() {
   tiler_->reset();
 }
 
 const char* TiledLayerImpl::LayerTypeAsString() const {
   return "cc::TiledLayerImpl";
 }
 
 }  // namespace cc