Revert 191364 "cc: Add ‘chromium_code’: 1 to cc.gyp and cc_t..."

trunk/src/cc/resources/tile_manager.cc

 // Copyright 2012 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/resources/tile_manager.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 13 matching lines @@
 namespace {
 
 // If we raster too fast we become upload bound, and pending
 // uploads consume memory. For maximum upload throughput, we would
 // want to allow for upload_throughput * pipeline_time of pending
 // uploads, after which we are just wasting memory. Since we don't
 // know our upload throughput yet, this just caps our memory usage.
 #if defined(OS_ANDROID)
 // For reference, the Nexus10 can upload 1MB in about 2.5ms.
 // Assuming a three frame deep pipeline this implies ~20MB.
-const size_t kMaxPendingUploadBytes = 20 * 1024 * 1024;
+const int kMaxPendingUploadBytes = 20 * 1024 * 1024;
 // TODO(epenner): We should remove this upload limit (crbug.com/176197)
-const size_t kMaxPendingUploads = 72;
+const int kMaxPendingUploads = 72;
 #else
-const size_t kMaxPendingUploadBytes = 100 * 1024 * 1024;
-const size_t kMaxPendingUploads = 1000;
+const int kMaxPendingUploadBytes = 100 * 1024 * 1024;
+const int kMaxPendingUploads = 1000;
 #endif
 
 #if defined(OS_ANDROID)
 const int kMaxNumPendingTasksPerThread = 8;
 #else
 const int kMaxNumPendingTasksPerThread = 40;
 #endif
 
 // Limit for time spent running cheap tasks during a single frame.
 // TODO(skyostil): Determine this limit more dynamically.
@@ skipping 108 matching lines @@
     bool prediction_benchmarking,
     RenderingStatsInstrumentation* rendering_stats_instrumentation)
     : client_(client),
       resource_pool_(ResourcePool::Create(resource_provider)),
       raster_worker_pool_(RasterWorkerPool::Create(this, num_raster_threads)),
       manage_tiles_pending_(false),
       manage_tiles_call_count_(0),
       bytes_pending_upload_(0),
       has_performed_uploads_since_last_flush_(false),
       ever_exceeded_memory_budget_(false),
-      rendering_stats_instrumentation_(rendering_stats_instrumentation),
       max_prepaint_tile_distance_(max_prepaint_tile_distance),
       use_cheapness_estimator_(use_cheapness_estimator),
       use_color_estimator_(use_color_estimator),
       prediction_benchmarking_(prediction_benchmarking),
       did_initialize_visible_tile_(false),
       pending_tasks_(0),
-      max_pending_tasks_(kMaxNumPendingTasksPerThread * num_raster_threads) {
+      max_pending_tasks_(kMaxNumPendingTasksPerThread * num_raster_threads),
+      rendering_stats_instrumentation_(rendering_stats_instrumentation) {
   for (int i = 0; i < NUM_STATES; ++i) {
     for (int j = 0; j < NUM_TREES; ++j) {
       for (int k = 0; k < NUM_BINS; ++k)
         raster_state_count_[i][j][k] = 0;
     }
   }
 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
   AssignGpuMemoryToTiles();
   // This should finish all pending tasks and release any uninitialized
   // resources.
   raster_worker_pool_.reset();
   AbortPendingTileUploads();
-  DCHECK_EQ(0u, tiles_with_pending_upload_.size());
-  DCHECK_EQ(0u, all_tiles_.size());
-  DCHECK_EQ(0u, live_or_allocated_tiles_.size());
+  DCHECK_EQ(tiles_with_pending_upload_.size(), 0);
+  DCHECK_EQ(all_tiles_.size(), 0);
+  DCHECK_EQ(live_or_allocated_tiles_.size(), 0);
 }
 
 void TileManager::SetGlobalState(
     const GlobalStateThatImpactsTilePriority& global_state) {
   global_state_ = global_state;
   resource_pool_->SetMaxMemoryUsageBytes(
       global_state_.memory_limit_in_bytes,
       global_state_.unused_memory_limit_in_bytes);
   ScheduleManageTiles();
   UpdateCheapTasksTimeLimit();
@@ skipping 821 matching lines @@
                                 10);
 
     if (metadata.prediction_benchmarking) {
       PicturePileImpl::Analysis analysis;
       picture_pile->AnalyzeInRect(rect, contents_scale, &analysis);
       bool is_predicted_cheap = analysis.is_cheap_to_raster;
       bool is_actually_cheap = duration.InMillisecondsF() <= 1.0f;
       RecordCheapnessPredictorResults(is_predicted_cheap, is_actually_cheap);
 
       DCHECK_EQ(bitmap.rowBytes(),
-                static_cast<size_t>(bitmap.width() * bitmap.bytesPerPixel()));
+                bitmap.width() * bitmap.bytesPerPixel());
 
       RecordSolidColorPredictorResults(
           reinterpret_cast<SkColor*>(bitmap.getPixels()),
           bitmap.getSize() / bitmap.bytesPerPixel(),
           analysis.is_solid_color,
           analysis.solid_color,
           analysis.is_transparent);
     }
   }
 }
@@ skipping 67 matching lines @@
     skia::LazyPixelRef* pixel_ref,
     RenderingStatsInstrumentation* stats_instrumentation) {
   TRACE_EVENT0("cc", "TileManager::RunImageDecodeTask");
   base::TimeTicks start_time = stats_instrumentation->StartRecording();
   pixel_ref->Decode();
   base::TimeDelta duration = stats_instrumentation->EndRecording(start_time);
   stats_instrumentation->AddDeferredImageDecode(duration);
 }
 
 }  // namespace cc