gpu: Remove Echo and SwapCompletion GL interfacess

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 159 matching lines @@
   DCHECK(!context_provider_.get());
 }
 
 void OutputSurface::SetUpContext3d() {
   DCHECK(context_provider_.get());
   DCHECK(client_);
 
   context_provider_->SetLostContextCallback(
       base::Bind(&OutputSurface::DidLoseOutputSurface,
                  base::Unretained(this)));
-  context_provider_->ContextSupport()->SetSwapBuffersCompleteCallback(
-      base::Bind(&OutputSurface::OnSwapBuffersComplete,
-                 base::Unretained(this)));
   context_provider_->SetMemoryPolicyChangedCallback(
       base::Bind(&OutputSurface::SetMemoryPolicy,
                  base::Unretained(this)));
 }
 
 void OutputSurface::ReleaseContextProvider() {
   DCHECK(client_);
   DCHECK(context_provider_.get());
   ResetContext3d();
 }
 
 void OutputSurface::ResetContext3d() {
   if (context_provider_.get()) {
     while (!pending_gpu_latency_query_ids_.empty()) {
       unsigned query_id = pending_gpu_latency_query_ids_.front();
       pending_gpu_latency_query_ids_.pop_front();
       context_provider_->ContextGL()->DeleteQueriesEXT(1, &query_id);
     }
     while (!available_gpu_latency_query_ids_.empty()) {
       unsigned query_id = available_gpu_latency_query_ids_.front();
       available_gpu_latency_query_ids_.pop_front();
       context_provider_->ContextGL()->DeleteQueriesEXT(1, &query_id);
     }
     context_provider_->SetLostContextCallback(
         ContextProvider::LostContextCallback());
     context_provider_->SetMemoryPolicyChangedCallback(
         ContextProvider::MemoryPolicyChangedCallback());
-    if (gpu::ContextSupport* support = context_provider_->ContextSupport())
-      support->SetSwapBuffersCompleteCallback(base::Closure());
   }
   context_provider_ = NULL;
 }
 
 void OutputSurface::EnsureBackbuffer() {
   if (software_device_)
     software_device_->EnsureBackbuffer();
 }
 
 void OutputSurface::DiscardBackbuffer() {
@@ skipping 32 matching lines @@
     client_->DidSwapBuffers();
     return;
   }
 
   DCHECK(context_provider_.get());
   DCHECK(frame->gl_frame_data);
 
   UpdateAndMeasureGpuLatency();
   if (frame->gl_frame_data->sub_buffer_rect ==
       gfx::Rect(frame->gl_frame_data->size)) {
-    context_provider_->ContextSupport()->Swap();
+    context_provider_->ContextGL()->SwapBuffers();
   } else {
-    context_provider_->ContextSupport()->PartialSwapBuffers(
-        frame->gl_frame_data->sub_buffer_rect);
+    const gfx::Rect& rect = frame->gl_frame_data->sub_buffer_rect;
+    context_provider_->ContextGL()->PostSubBufferCHROMIUM(
+        rect.x(), rect.y(), rect.width(), rect.height());
   }
+  uint32_t sync_point =
+      context_provider_->ContextGL()->InsertSyncPointCHROMIUM();
+  context_provider_->ContextSupport()->SignalSyncPoint(
+      sync_point,
+      base::Bind(&OutputSurface::OnSwapBuffersComplete,
+                 weak_ptr_factory_.GetWeakPtr()));
 
   client_->DidSwapBuffers();
 }
 
 base::TimeDelta OutputSurface::GpuLatencyEstimate() {
   if (context_provider_.get() && !capabilities_.adjust_deadline_for_parent)
     return gpu_latency_history_.Percentile(kGpuLatencyEstimationPercentile);
   else
     return base::TimeDelta();
 }
@@ skipping 81 matching lines @@
   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