Add optimization for CHROMIUM_subscribe_uniform extension.

content/common/gpu/gpu_channel.cc

 // Copyright (c) 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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/common/gpu/gpu_channel.h"
 
@@ skipping 11 matching lines @@
 #include "content/common/gpu/gpu_channel_manager.h"
 #include "content/common/gpu/gpu_memory_buffer_factory.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/common/value_state.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "gpu/command_buffer/service/image_factory.h"
 #include "gpu/command_buffer/service/mailbox_manager_impl.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
+#include "gpu/command_buffer/service/valuebuffer_manager.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/message_filter.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image_shared_memory.h"
 #include "ui/gl/gl_surface.h"
 
 #if defined(OS_POSIX)
 #include "ipc/ipc_channel_posix.h"
 #endif
 
@@ skipping 376 matching lines @@
       num_stubs_descheduled_(0),
       allow_future_sync_points_(allow_future_sync_points),
       weak_factory_(this) {
   DCHECK(gpu_channel_manager);
   DCHECK(client_id);
 
   channel_id_ = IPC::Channel::GenerateVerifiedChannelID("gpu");
   const base::CommandLine* command_line =
       base::CommandLine::ForCurrentProcess();
   log_messages_ = command_line->HasSwitch(switches::kLogPluginMessages);
+
+  subscription_ref_set_ = new gpu::gles2::SubscriptionRefSet();
+  subscription_ref_set_->AddObserver(this);
 }
 
 GpuChannel::~GpuChannel() {
   STLDeleteElements(&deferred_messages_);
+  subscription_ref_set_->RemoveObserver(this);
   if (preempting_flag_.get())
     preempting_flag_->Reset();
 }
 
 void GpuChannel::Init(base::MessageLoopProxy* io_message_loop,
                       base::WaitableEvent* shutdown_event) {
   DCHECK(!channel_.get());
 
   // Map renderer ID to a (single) channel to that process.
   channel_ = IPC::SyncChannel::Create(channel_id_,
@@ skipping 63 matching lines @@
   }
 
   if (!channel_) {
     delete message;
     return false;
   }
 
   return channel_->Send(message);
 }
 
+void GpuChannel::OnAddSubscription(unsigned int target) {
+  gpu_channel_manager()->Send(
+      new GpuHostMsg_AddSubscription(client_id_, target));
+}
+
+void GpuChannel::OnRemoveSubscription(unsigned int target) {
+  gpu_channel_manager()->Send(
+      new GpuHostMsg_RemoveSubscription(client_id_, target));
+}
+
 void GpuChannel::RequeueMessage() {
   DCHECK(currently_processing_message_);
   deferred_messages_.push_front(
       new IPC::Message(*currently_processing_message_));
   messages_processed_--;
   currently_processing_message_ = NULL;
 }
 
 void GpuChannel::OnScheduled() {
   if (handle_messages_scheduled_)
@@ skipping 49 matching lines @@
   bool use_virtualized_gl_context = false;
 #if defined(OS_MACOSX)
   use_virtualized_gl_context = true;
 #endif
 
   scoped_ptr<GpuCommandBufferStub> stub(
       new GpuCommandBufferStub(this,
                                share_group,
                                window,
                                mailbox_manager_.get(),
+                               subscription_ref_set_.get(),
                                pending_valuebuffer_state_.get(),
                                gfx::Size(),
                                disallowed_features_,
                                init_params.attribs,
                                init_params.gpu_preference,
                                use_virtualized_gl_context,
                                route_id,
                                surface_id,
                                watchdog_,
                                software_,
@@ skipping 139 matching lines @@
     int32 route_id,
     bool* succeeded) {
   TRACE_EVENT0("gpu", "GpuChannel::OnCreateOffscreenCommandBuffer");
   GpuCommandBufferStub* share_group = stubs_.Lookup(init_params.share_group_id);
 
   scoped_ptr<GpuCommandBufferStub> stub(new GpuCommandBufferStub(
       this,
       share_group,
       gfx::GLSurfaceHandle(),
       mailbox_manager_.get(),
+      subscription_ref_set_.get(),
       pending_valuebuffer_state_.get(),
       size,
       disallowed_features_,
       init_params.attribs,
       init_params.gpu_preference,
       false,
       route_id,
       0,
       watchdog_,
       software_,
@@ skipping 102 matching lines @@
     }
   }
 }
 
 void GpuChannel::HandleUpdateValueState(
     unsigned int target, const gpu::ValueState& state) {
   pending_valuebuffer_state_->UpdateState(target, state);
 }
 
 }  // namespace content