cc: Prevent ResourceUpdateContoller from uploading textures after lost context

cc/resources/resource_provider.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/resource_provider.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/containers/hash_tables.h"
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "cc/base/util.h"
 #include "cc/output/gl_renderer.h"  // For the GLC() macro.
 #include "cc/resources/platform_color.h"
 #include "cc/resources/returned_resource.h"
 #include "cc/resources/shared_bitmap_manager.h"
 #include "cc/resources/transferable_resource.h"
 #include "cc/scheduler/texture_uploader.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
+#include "ui/gfx/frame_time.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/vector2d.h"
 
 using blink::WebGraphicsContext3D;
 
 namespace cc {
 
 class IdAllocator {
  public:
   virtual ~IdAllocator() {}
@@ skipping 606 matching lines @@
   return texture_uploader_->NumBlockingUploads();
 }
 
 void ResourceProvider::MarkPendingUploadsAsNonBlocking() {
   if (!texture_uploader_)
     return;
 
   texture_uploader_->MarkPendingUploadsAsNonBlocking();
 }
 
-double ResourceProvider::EstimatedUploadsPerSecond() {
+size_t ResourceProvider::EstimatedUploadsPerTick() {
   if (!texture_uploader_)
-    return 0.0;
+    return 1u;
 
-  return texture_uploader_->EstimatedTexturesPerSecond();
+  double textures_per_second = texture_uploader_->EstimatedTexturesPerSecond();
+  size_t textures_per_tick = floor(
+      kTextureUploadTickRate * textures_per_second);
+  return textures_per_tick ? textures_per_tick : 1u;
 }
 
 void ResourceProvider::FlushUploads() {
   if (!texture_uploader_)
     return;
 
   texture_uploader_->Flush();
 }
 
 void ResourceProvider::ReleaseCachedData() {
   if (!texture_uploader_)
     return;
 
   texture_uploader_->ReleaseCachedQueries();
 }
 
-base::TimeDelta ResourceProvider::TextureUpdateTickRate() {
+base::TimeTicks ResourceProvider::EstimatedUploadCompletionTime(
+    size_t uploads_per_tick) {
+  if (lost_output_surface_)
+    return base::TimeTicks();
+
   // Software resource uploads happen on impl thread, so don't bother batching
   // them up and trying to wait for them to complete.
-  double rate =
-      texture_uploader_ ? kTextureUploadTickRate : kSoftwareUploadTickRate;
-  return base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond *
-                                           rate);
+  if (!texture_uploader_) {
+    return gfx::FrameTime::Now() + base::TimeDelta::FromMicroseconds(
+        base::Time::kMicrosecondsPerSecond * kSoftwareUploadTickRate);
+  }
+
+  base::TimeDelta upload_one_texture_time =
+      base::TimeDelta::FromMicroseconds(
+          base::Time::kMicrosecondsPerSecond * kTextureUploadTickRate) /
+      uploads_per_tick;
+
+  size_t total_uploads = NumBlockingUploads() + uploads_per_tick;
+  return gfx::FrameTime::Now() + upload_one_texture_time * total_uploads;
 }
 
 void ResourceProvider::Flush() {
   DCHECK(thread_checker_.CalledOnValidThread());
   WebGraphicsContext3D* context3d = Context3d();
   if (context3d)
     context3d->flush();
 }
 
 void ResourceProvider::Finish() {
@@ skipping 1144 matching lines @@
   context->getIntegerv(GL_ACTIVE_TEXTURE, &active_unit);
   return active_unit;
 }
 
 blink::WebGraphicsContext3D* ResourceProvider::Context3d() const {
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->Context3d() : NULL;
 }
 
 }  // namespace cc