Create new GLSurface for cross process image transport.

gpu/command_buffer/service/gpu_scheduler.cc

 // Copyright (c) 2011 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 "gpu/command_buffer/service/gpu_scheduler.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "ui/gfx/gl/gl_context.h"
 #include "ui/gfx/gl/gl_bindings.h"
 #include "ui/gfx/gl/gl_surface.h"
 #include "ui/gfx/gl/gl_switches.h"
 
 using ::base::SharedMemory;
 
 namespace gpu {
 
 GpuScheduler::GpuScheduler(CommandBuffer* command_buffer,
                            SurfaceManager* surface_manager,
                            gles2::ContextGroup* group)
     : command_buffer_(command_buffer),
       commands_per_update_(100),
       unscheduled_count_(0),
-#if defined(OS_MACOSX) || defined(TOUCH_UI)
+#if defined(OS_MACOSX)
       swap_buffers_count_(0),
       acknowledged_swap_buffers_count_(0),
 #endif
       method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(command_buffer);
   decoder_.reset(gles2::GLES2Decoder::Create(surface_manager, group));
   decoder_->set_engine(this);
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableGPUServiceLogging)) {
     decoder_->set_debug(true);
   }
 }
 
 GpuScheduler::GpuScheduler(CommandBuffer* command_buffer,
                            gles2::GLES2Decoder* decoder,
                            CommandParser* parser,
                            int commands_per_update)
     : command_buffer_(command_buffer),
       commands_per_update_(commands_per_update),
       unscheduled_count_(0),
-#if defined(OS_MACOSX) || defined(TOUCH_UI)
+#if defined(OS_MACOSX)
       swap_buffers_count_(0),
       acknowledged_swap_buffers_count_(0),
 #endif
       method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(command_buffer);
   decoder_.reset(decoder);
   parser_.reset(parser);
 }
 
 GpuScheduler::~GpuScheduler() {
   Destroy();
 }
 
 bool GpuScheduler::InitializeCommon(
     const scoped_refptr<gfx::GLSurface>& surface,
     const scoped_refptr<gfx::GLContext>& context,
     const gfx::Size& size,
     const gles2::DisallowedExtensions& disallowed_extensions,
     const char* allowed_extensions,
     const std::vector<int32>& attribs) {
   DCHECK(context);
 
   if (!context->MakeCurrent(surface))
     return false;
 
-#if !defined(OS_MACOSX)
+#if !defined(OS_MACOSX) && !defined(TOUCH_UI)
   // Set up swap interval for onscreen contexts.
   if (!surface->IsOffscreen()) {
     if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableGpuVsync))
       context->SetSwapInterval(0);
     else
       context->SetSwapInterval(1);
   }
 #endif
 
   // Do not limit to a certain number of commands before scheduling another
@@ skipping 45 matching lines @@
 
 bool GpuScheduler::SetParent(GpuScheduler* parent_scheduler,
                              uint32 parent_texture_id) {
   if (parent_scheduler)
     return decoder_->SetParent(parent_scheduler->decoder_.get(),
                                parent_texture_id);
   else
     return decoder_->SetParent(NULL, 0);
 }
 
-#if defined(OS_MACOSX) || defined(TOUCH_UI)
+#if defined(OS_MACOSX)
 namespace {
 const unsigned int kMaxOutstandingSwapBuffersCallsPerOnscreenContext = 1;
 }
 #endif
 
 void GpuScheduler::PutChanged(bool sync) {
   TRACE_EVENT1("gpu", "GpuScheduler:PutChanged", "this", this);
   CommandBuffer::State state = command_buffer_->GetState();
   parser_->set_put(state.put_offset);
 
@@ skipping 19 matching lines @@
     if (!decoder_->MakeCurrent()) {
       LOG(ERROR) << "Context lost because MakeCurrent failed.";
       command_buffer_->SetContextLostReason(decoder_->GetContextLostReason());
       command_buffer_->SetParseError(error::kLostContext);
       return;
     }
   }
 
 #if defined(OS_MACOSX)
   bool do_rate_limiting = surface_.get() != NULL;
-#elif defined(TOUCH_UI)
-  bool do_rate_limiting = back_surface_.get() != NULL;
-#endif
-
-#if defined(OS_MACOSX) || defined(TOUCH_UI)
   // Don't swamp the browser process with SwapBuffers calls it can't handle.
   if (do_rate_limiting &&
       swap_buffers_count_ - acknowledged_swap_buffers_count_ >=
       kMaxOutstandingSwapBuffersCallsPerOnscreenContext) {
     TRACE_EVENT0("gpu", "EarlyOut_OSX_Throttle");
     // Stop doing work on this command buffer. In the GPU process,
     // receipt of the GpuMsg_AcceleratedSurfaceBuffersSwappedACK
     // message causes ProcessCommands to be scheduled again.
     return;
   }
@@ skipping 92 matching lines @@
 
 int32 GpuScheduler::GetGetOffset() {
   return parser_->get();
 }
 
 void GpuScheduler::ResizeOffscreenFrameBuffer(const gfx::Size& size) {
   decoder_->ResizeOffscreenFrameBuffer(size);
 }
 
 void GpuScheduler::SetResizeCallback(Callback1<gfx::Size>::Type* callback) {
-  wrapped_resize_callback_.reset(callback);
-  decoder_->SetResizeCallback(
-      NewCallback(this,
-                  &GpuScheduler::WillResize));
+  decoder_->SetResizeCallback(callback);
 }
 
 void GpuScheduler::SetSwapBuffersCallback(
     Callback0::Type* callback) {
   wrapped_swap_buffers_callback_.reset(callback);
   decoder_->SetSwapBuffersCallback(
       NewCallback(this,
                   &GpuScheduler::WillSwapBuffers));
 }
 
 void GpuScheduler::SetCommandProcessedCallback(
     Callback0::Type* callback) {
   command_processed_callback_.reset(callback);
 }
 
 void GpuScheduler::SetTokenCallback(
     const base::Callback<void(int32)>& callback) {
   DCHECK(set_token_callback_.is_null());
   set_token_callback_ = callback;
 }
 
 void GpuScheduler::ScheduleProcessCommands() {
   MessageLoop::current()->PostTask(
       FROM_HERE,
       method_factory_.NewRunnableMethod(&GpuScheduler::ProcessCommands));
 }
 
-void GpuScheduler::WillResize(gfx::Size size) {
-  if (wrapped_resize_callback_.get()) {
-    wrapped_resize_callback_->Run(size);
-  }
-}
-
 }  // namespace gpu