Pass resourceless software mode in BeginFrameArgs

cc/output/output_surface.cc

 // Copyright (c) 2013 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/output_surface.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 89 matching lines @@
   client_->DidLoseOutputSurface();
 }
 
 void OutputSurface::SetExternalStencilTest(bool enabled) {
   external_stencil_test_enabled_ = enabled;
 }
 
 void OutputSurface::SetExternalDrawConstraints(const gfx::Transform& transform,
                                                const gfx::Rect& viewport,
                                                const gfx::Rect& clip,
+                                               bool resourceless_software_draw,
                                                bool valid_for_tile_management) {
-  client_->SetExternalDrawConstraints(
-      transform, viewport, clip, valid_for_tile_management);
+  client_->SetExternalDrawConstraints(transform,
+                                      viewport,
+                                      clip,
+                                      resourceless_software_draw,
+                                      valid_for_tile_management);
 }
 
 OutputSurface::~OutputSurface() {
   ResetContext3d();
 }
 
 bool OutputSurface::HasExternalStencilTest() const {
   return external_stencil_test_enabled_;
 }
 
-bool OutputSurface::ForcedDrawToSoftwareDevice() const { return false; }
-
 bool OutputSurface::BindToClient(OutputSurfaceClient* client) {
   DCHECK(client);
   client_ = client;
   bool success = true;
 
   if (context_provider_) {
     success = context_provider_->BindToCurrentThread();
     if (success)
       SetUpContext3d();
   }
@@ skipping 133 matching lines @@
 
 base::TimeDelta OutputSurface::GpuLatencyEstimate() {
   if (context_provider_ && !capabilities_.adjust_deadline_for_parent)
     return gpu_latency_history_.Percentile(kGpuLatencyEstimationPercentile);
   else
     return base::TimeDelta();
 }
 
 void OutputSurface::UpdateAndMeasureGpuLatency() {
   // http://crbug.com/306690  tracks re-enabling latency queries.
-#if 0

[brianderson, 2014/07/08 21:26:12]

I'm removing this in https://codereview.chromium.org/323423005. There's a bunch
of other logic that can be removed too. Will rebase that patch.

[boliu, 2014/07/08 21:31:14]

Yeah presubmit wouldn't let me upload if I don't remove this :/

Looks like yours can go in now? You can cq now and I can rebase after if you
want.

-  // We only care about GPU latency for surfaces that do not have a parent
-  // compositor, since surfaces that do have a parent compositor can use
-  // mailboxes or delegated rendering to send frames to their parent without
-  // incurring GPU latency.
-  if (capabilities_.adjust_deadline_for_parent)
-    return;
-
-  while (pending_gpu_latency_query_ids_.size()) {
-    unsigned query_id = pending_gpu_latency_query_ids_.front();
-    unsigned query_complete = 1;
-    context_provider_->ContextGL()->GetQueryObjectuivEXT(
-        query_id, GL_QUERY_RESULT_AVAILABLE_EXT, &query_complete);
-    if (!query_complete)
-      break;
-
-    unsigned value = 0;
-    context_provider_->ContextGL()->GetQueryObjectuivEXT(
-        query_id, GL_QUERY_RESULT_EXT, &value);
-    pending_gpu_latency_query_ids_.pop_front();
-    available_gpu_latency_query_ids_.push_back(query_id);
-
-    base::TimeDelta latency = base::TimeDelta::FromMicroseconds(value);
-    base::TimeDelta latency_estimate = GpuLatencyEstimate();
-    gpu_latency_history_.InsertSample(latency);
-
-    base::TimeDelta latency_overestimate;
-    base::TimeDelta latency_underestimate;
-    if (latency > latency_estimate)
-      latency_underestimate = latency - latency_estimate;
-    else
-      latency_overestimate = latency_estimate - latency;
-    UMA_HISTOGRAM_CUSTOM_TIMES("Renderer.GpuLatency",
-                               latency,
-                               base::TimeDelta::FromMilliseconds(1),
-                               base::TimeDelta::FromMilliseconds(100),
-                               50);
-    UMA_HISTOGRAM_CUSTOM_TIMES("Renderer.GpuLatencyUnderestimate",
-                               latency_underestimate,
-                               base::TimeDelta::FromMilliseconds(1),
-                               base::TimeDelta::FromMilliseconds(100),
-                               50);
-    UMA_HISTOGRAM_CUSTOM_TIMES("Renderer.GpuLatencyOverestimate",
-                               latency_overestimate,
-                               base::TimeDelta::FromMilliseconds(1),
-                               base::TimeDelta::FromMilliseconds(100),
-                               50);
-  }
-
-  unsigned gpu_latency_query_id;
-  if (available_gpu_latency_query_ids_.size()) {
-    gpu_latency_query_id = available_gpu_latency_query_ids_.front();
-    available_gpu_latency_query_ids_.pop_front();
-  } else {
-    context_provider_->ContextGL()->GenQueriesEXT(1, &gpu_latency_query_id);
-  }
-
-  context_provider_->ContextGL()->BeginQueryEXT(GL_LATENCY_QUERY_CHROMIUM,
-                                                gpu_latency_query_id);
-  context_provider_->ContextGL()->EndQueryEXT(GL_LATENCY_QUERY_CHROMIUM);
-  pending_gpu_latency_query_ids_.push_back(gpu_latency_query_id);
-#endif
 }
 
 void OutputSurface::PostSwapBuffersComplete() {
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&OutputSurface::OnSwapBuffersComplete,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 // We don't post tasks bound to the client directly since they might run
 // after the OutputSurface has been destroyed.
 void OutputSurface::OnSwapBuffersComplete() {
   client_->DidSwapBuffersComplete();
 }
 
 void OutputSurface::SetMemoryPolicy(const ManagedMemoryPolicy& policy) {
   TRACE_EVENT1("cc", "OutputSurface::SetMemoryPolicy",
                "bytes_limit_when_visible", policy.bytes_limit_when_visible);
   // Just ignore the memory manager when it says to set the limit to zero
   // bytes. This will happen when the memory manager thinks that the renderer
   // is not visible (which the renderer knows better).
   if (policy.bytes_limit_when_visible)
     client_->SetMemoryPolicy(policy);
 }
 
 }  // namespace cc