Remove a lame assertion from one_copy_tile_task_worker_pool.cc.

cc/raster/one_copy_tile_task_worker_pool.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/raster/one_copy_tile_task_worker_pool.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 323 matching lines @@
     // Allocate GpuMemoryBuffer if necessary. If using partial raster, we
     // must allocate a buffer with BufferUsage CPU_READ_WRITE_PERSISTENT.
     if (!staging_buffer->gpu_memory_buffer) {
       staging_buffer->gpu_memory_buffer =
           resource_provider_->gpu_memory_buffer_manager()
               ->AllocateGpuMemoryBuffer(
                   staging_buffer->size, BufferFormat(resource->format()),
                   use_partial_raster_
                       ? gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT
                       : gfx::BufferUsage::GPU_READ_CPU_READ_WRITE);
-      DCHECK_EQ(gfx::NumberOfPlanesForBufferFormat(
-                    staging_buffer->gpu_memory_buffer->GetFormat()),
-                1u);
     }
 
     gfx::Rect playback_rect = raster_full_rect;
     if (use_partial_raster_ && previous_content_id) {
       // Reduce playback rect to dirty region if the content id of the staging
       // buffer matches the prevous content id.
       if (previous_content_id == staging_buffer->content_id)
         playback_rect.Intersect(raster_dirty_rect);
     }
 
     if (staging_buffer->gpu_memory_buffer) {
       gfx::GpuMemoryBuffer* buffer = staging_buffer->gpu_memory_buffer.get();
       DCHECK_EQ(1u, gfx::NumberOfPlanesForBufferFormat(buffer->GetFormat()));

[ncarter (slow), 2016/02/05 22:05:28]

This assertion is the same as the one I'm removing, except that it doesn't crash
when AllocateGpuMemoryBuffer fails.

[ericrk, 2016/02/05 23:30:42]

I agree that the above was redundant... I'm a bit curious as to why we proceed
with as much work as we do when this operation fails - it seems like we're
pretty safe in guarding against direct failures, but we do end up issuing a
bunch of GL commands that hopefully do nothing, but it's hard to know for
sure...

Given that you're just trying to solve the simpler problem of the bad DCECK,
LGTM.

       bool rv = buffer->Map();
       DCHECK(rv);
       DCHECK(buffer->memory(0));
       // TileTaskWorkerPool::PlaybackToMemory only supports unsigned strides.
       DCHECK_GE(buffer->stride(0), 0);
 
       DCHECK(!playback_rect.IsEmpty())
           << "Why are we rastering a tile that's not dirty?";
       TileTaskWorkerPool::PlaybackToMemory(
           buffer->memory(0), resource->format(), staging_buffer->size,
@@ skipping 351 matching lines @@
         return;
 
       busy_buffers_.front()->DestroyGLResources(gl);
       RemoveStagingBuffer(busy_buffers_.front().get());
       busy_buffers_.pop_front();
     }
   }
 }
 
 }  // namespace cc