Removed implementation of CHROMIUM_subscribe_uniform

gpu/ipc/service/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.
 
 #include "gpu/ipc/service/gpu_channel.h"
 
 #include <utility>
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 13 matching lines @@
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/common/mailbox.h"
-#include "gpu/command_buffer/common/value_state.h"
 #include "gpu/command_buffer/service/command_executor.h"
 #include "gpu/command_buffer/service/image_factory.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
-#include "gpu/command_buffer/service/valuebuffer_manager.h"
 #include "gpu/ipc/common/gpu_messages.h"
 #include "gpu/ipc/service/gpu_channel_manager.h"
 #include "gpu/ipc/service/gpu_channel_manager_delegate.h"
 #include "gpu/ipc/service/gpu_memory_buffer_factory.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"
 
@@ skipping 545 matching lines @@
       unhandled_message_listener_(nullptr),
       channel_id_(IPC::Channel::GenerateVerifiedChannelID("gpu")),
       preempting_flag_(preempting_flag),
       preempted_flag_(preempted_flag),
       client_id_(client_id),
       client_tracing_id_(client_tracing_id),
       task_runner_(task_runner),
       io_task_runner_(io_task_runner),
       share_group_(share_group),
       mailbox_manager_(mailbox),
-      subscription_ref_set_(new gles2::SubscriptionRefSet),
-      pending_valuebuffer_state_(new ValueStateMap),
       watchdog_(watchdog),
       allow_view_command_buffers_(allow_view_command_buffers),
       allow_real_time_streams_(allow_real_time_streams),
       weak_factory_(this) {
   DCHECK(gpu_channel_manager);
   DCHECK(client_id);
 
   filter_ = new GpuChannelMessageFilter();
 
   scoped_refptr<GpuChannelMessageQueue> control_queue =
       CreateStream(GPU_STREAM_DEFAULT, GpuStreamPriority::HIGH);
   AddRouteToStream(MSG_ROUTING_CONTROL, GPU_STREAM_DEFAULT);
-
-  subscription_ref_set_->AddObserver(this);
 }
 
 GpuChannel::~GpuChannel() {
   // Clear stubs first because of dependencies.
   stubs_.clear();
 
   for (auto& kv : streams_)
     kv.second->Disable();
 
-  subscription_ref_set_->RemoveObserver(this);
   if (preempting_flag_.get())
     preempting_flag_->Reset();
 }
 
 IPC::ChannelHandle GpuChannel::Init(base::WaitableEvent* shutdown_event) {
   DCHECK(shutdown_event);
   DCHECK(!channel_);
 
   IPC::ChannelHandle channel_handle(channel_id_);
 
@@ skipping 63 matching lines @@
            << " with type " << message->type();
 
   if (!channel_) {
     delete message;
     return false;
   }
 
   return channel_->Send(message);
 }
 
-void GpuChannel::OnAddSubscription(unsigned int target) {
-  gpu_channel_manager()->delegate()->AddSubscription(client_id_, target);
-}
-
-void GpuChannel::OnRemoveSubscription(unsigned int target) {
-  gpu_channel_manager()->delegate()->RemoveSubscription(client_id_, target);
-}
-
 void GpuChannel::OnStreamRescheduled(int32_t stream_id, bool scheduled) {
   scoped_refptr<GpuChannelMessageQueue> queue = LookupStream(stream_id);
   DCHECK(queue);
   queue->OnRescheduled(scheduled);
 }
 
 GpuCommandBufferStub* GpuChannel::LookupCommandBuffer(int32_t route_id) {
   return stubs_.get(route_id);
 }
 
@@ skipping 221 matching lines @@
   }
 
   if (share_group && share_group->decoder()->WasContextLost()) {
     DLOG(ERROR) << "GpuChannel::OnCreateCommandBuffer(): shared context was "
                    "already lost";
     return;
   }
 
   std::unique_ptr<GpuCommandBufferStub> stub(new GpuCommandBufferStub(
       this, sync_point_manager_, task_runner_.get(), share_group,
-      surface_handle, mailbox_manager_.get(), preempted_flag_.get(),
-      subscription_ref_set_.get(), pending_valuebuffer_state_.get(), size,
+      surface_handle, mailbox_manager_.get(), preempted_flag_.get(), size,
       disallowed_features_, init_params.attribs, init_params.gpu_preference,
       init_params.stream_id, route_id, watchdog_, init_params.active_url));
 
   scoped_refptr<GpuChannelMessageQueue> queue = LookupStream(stream_id);
   if (!queue)
     queue = CreateStream(stream_id, stream_priority);
 
   if (!AddRoute(route_id, stream_id, stub.get())) {
     DestroyStreamIfNecessary(queue);
     DLOG(ERROR) << "GpuChannel::OnCreateCommandBuffer(): failed to add route";
@@ skipping 89 matching lines @@
           ->AsImageFactory()
           ->CreateImageForGpuMemoryBuffer(handle,
                                           size,
                                           format,
                                           internalformat,
                                           client_id_);
     }
   }
 }
 
-void GpuChannel::HandleUpdateValueState(
-    unsigned int target, const ValueState& state) {
-  pending_valuebuffer_state_->UpdateState(target, state);
-}
-
 }  // namespace gpu