Removed "compositor" child window that was created by the GPU process.

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/compiler_specific.h"
 #include "base/message_loop.h"
 #include "gpu/common/gpu_trace_event.h"
 #include "ui/gfx/gl/gl_context.h"
 #include "ui/gfx/gl/gl_bindings.h"
 
 using ::base::SharedMemory;
 
 namespace gpu {
 
 GpuScheduler::GpuScheduler(CommandBuffer* command_buffer,
                            gles2::ContextGroup* group)
     : command_buffer_(command_buffer),
       commands_per_update_(100),
+      unscheduled_count_(0),
 #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(group));
   decoder_->set_engine(this);
 }
 
 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)
       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);
 }
 
@@ skipping 66 matching lines @@
 const unsigned int kMaxOutstandingSwapBuffersCallsPerOnscreenContext = 1;
 }
 #endif
 
 void GpuScheduler::ProcessCommands() {
   GPU_TRACE_EVENT0("gpu", "GpuScheduler:ProcessCommands");
   CommandBuffer::State state = command_buffer_->GetState();
   if (state.error != error::kNoError)
     return;
 
+  if (unscheduled_count_ > 0)
+    return;
+
   if (decoder_.get()) {
     if (!decoder_->MakeCurrent()) {
       LOG(ERROR) << "Context lost because MakeCurrent failed.";
       command_buffer_->SetParseError(error::kLostContext);
       return;
     }
   }
 
   parser_->set_put(state.put_offset);
 
@@ skipping 16 matching lines @@
          !parser_->IsEmpty()) {
     error = parser_->ProcessCommand();
 
     if (error == error::kWaiting || error == error::kYield) {
       break;
     } else if (error::IsError(error)) {
       command_buffer_->SetParseError(error);
       return;
     }
 
+    if (unscheduled_count_ > 0)
+      break;
+
     ++commands_processed;
     if (command_processed_callback_.get()) {
       command_processed_callback_->Run();
     }
   }
 
   command_buffer_->SetGetOffset(static_cast<int32>(parser_->get()));
 
-  if (error != error::kWaiting && !parser_->IsEmpty()) {
+  if (unscheduled_count_ == 0 &&
+      error != error::kWaiting &&
+      !parser_->IsEmpty()) {
     ScheduleProcessCommands();
   }
 }
 
-void GpuScheduler::ScheduleProcessCommands() {
-  MessageLoop::current()->PostTask(
-      FROM_HERE,
-      method_factory_.NewRunnableMethod(&GpuScheduler::ProcessCommands));
+void GpuScheduler::SetScheduled(bool scheduled) {
+  if (scheduled) {
+    --unscheduled_count_;
+    DCHECK_GE(unscheduled_count_, 0);
+
+    if (unscheduled_count_ == 0)
+      ScheduleProcessCommands();
+  } else {
+    ++unscheduled_count_;
+  }
 }
 
 Buffer GpuScheduler::GetSharedMemoryBuffer(int32 shm_id) {
   return command_buffer_->GetTransferBuffer(shm_id);
 }
 
 void GpuScheduler::set_token(int32 token) {
   command_buffer_->SetToken(token);
 }
 
@@ skipping 23 matching lines @@
   decoder_->SetSwapBuffersCallback(
       NewCallback(this,
                   &GpuScheduler::WillSwapBuffers));
 }
 
 void GpuScheduler::SetCommandProcessedCallback(
     Callback0::Type* callback) {
   command_processed_callback_.reset(callback);
 }
 
+void GpuScheduler::ScheduleProcessCommands() {
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      method_factory_.NewRunnableMethod(&GpuScheduler::ProcessCommands));
+}
+
 }  // namespace gpu