Add optimization for CHROMIUM_subscribe_uniform extension.

content/browser/renderer_host/render_widget_host_impl.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 "content/browser/renderer_host/render_widget_host_impl.h"
 
 #include <math.h>
 #include <set>
 #include <utility>
 
@@ skipping 215 matching lines @@
   RenderViewHostImpl* rvh = static_cast<RenderViewHostImpl*>(
       IsRenderView() ? RenderViewHost::From(this) : NULL);
   if (BrowserPluginGuest::IsGuest(rvh) ||
       !base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableHangMonitor)) {
     hang_monitor_timeout_.reset(new TimeoutMonitor(
         base::Bind(&RenderWidgetHostImpl::RendererIsUnresponsive,
                    weak_factory_.GetWeakPtr())));
   }
 
+  pending_valuebuffer_state_ = new gpu::ValueStateMap();
+
   subscribe_uniform_enabled_ =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableSubscribeUniformExtension);
 }
 
 RenderWidgetHostImpl::~RenderWidgetHostImpl() {
   if (view_weak_)
     view_weak_->RenderWidgetHostGone();
   SetView(NULL);
 
@@ skipping 651 matching lines @@
     return;
 
   if (touch_emulator_ && touch_emulator_->HandleMouseEvent(mouse_event))
     return;
 
   input_router_->SendMouseEvent(MouseEventWithLatencyInfo(mouse_event,
                                                           latency_info));
 
   // Pass mouse state to gpu service if the subscribe uniform
   // extension is enabled.
-  // TODO(orglofch): Only pass mouse information if one of the GL Contexts
-  // is subscribed to GL_MOUSE_POSITION_CHROMIUM
   if (subscribe_uniform_enabled_) {
     gpu::ValueState state;
     state.int_value[0] = mouse_event.x;
     state.int_value[1] = mouse_event.y;
-    GpuProcessHost::SendOnIO(
-        GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
-        CAUSE_FOR_GPU_LAUNCH_NO_LAUNCH,
-        new GpuMsg_UpdateValueState(
-            process_->GetID(), GL_MOUSE_POSITION_CHROMIUM, state));
+    SendUpdateValueState(GL_MOUSE_POSITION_CHROMIUM, state);
   }
 }
 
 void RenderWidgetHostImpl::OnPointerEventActivate() {
 }
 
 void RenderWidgetHostImpl::ForwardWheelEvent(
     const WebMouseWheelEvent& wheel_event) {
   ForwardWheelEventWithLatencyInfo(wheel_event, ui::LatencyInfo());
 }
@@ skipping 1420 matching lines @@
 
 void RenderWidgetHostImpl::OnSnapshotDataReceivedAsync(
     int snapshot_id,
     scoped_refptr<base::RefCountedBytes> png_data) {
   if (png_data.get())
     OnSnapshotDataReceived(snapshot_id, png_data->front(), png_data->size());
   else
     OnSnapshotDataReceived(snapshot_id, NULL, 0);
 }
 
+void RenderWidgetHostImpl::SendUpdateValueState(unsigned int target,
+                                                const gpu::ValueState& state) {
+  if (subscription_set_.find(GL_MOUSE_POSITION_CHROMIUM)

[piman, 2014/12/10 06:57:10]

s/GL_MOUSE_POSITION_CHROMIUM/target/ in this method?

[orglofch, 2014/12/10 21:54:48]

Done.

+      != subscription_set_.end()) {
+    GpuProcessHost::SendOnIO(
+        GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
+        CAUSE_FOR_GPU_LAUNCH_NO_LAUNCH,
+        new GpuMsg_UpdateValueState(
+            process_->GetID(), GL_MOUSE_POSITION_CHROMIUM, state));

[piman, 2014/12/10 06:57:10]

Actually, I'm realizing, this doesn't make much sense to have a per-process map
that has per-RWH values.

The event is relative to the renderer. You can have different renderers in
different windows, and moving the mouse between those renderers would send
spurious values to the other ones.

That's kind of why you have a strange map lookup in GpuProcessHostUIShim.

[orglofch, 2014/12/10 21:54:48]

Done. Moved to RenderProcessHost.

+  } else {
+    // Store the ValueState locally in case a Valuebuffer subscribes to it later
+    pending_valuebuffer_state_->UpdateState(GL_MOUSE_POSITION_CHROMIUM, state);
+  }
+}
+
 // static
 void RenderWidgetHostImpl::CompositorFrameDrawn(
     const std::vector<ui::LatencyInfo>& latency_info) {
   for (size_t i = 0; i < latency_info.size(); i++) {
     std::set<RenderWidgetHostImpl*> rwhi_set;
     for (ui::LatencyInfo::LatencyMap::const_iterator b =
              latency_info[i].latency_components.begin();
          b != latency_info[i].latency_components.end();
          ++b) {
       if (b->first.first == ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT ||
@@ skipping 36 matching lines @@
       ++lc;
     }
   }
 
   // Add newly generated components into the latency info
   for (lc = new_components.begin(); lc != new_components.end(); ++lc) {
     latency_info->latency_components[lc->first] = lc->second;
   }
 }
 
+void RenderWidgetHostImpl::OnAddSubscription(unsigned int target) {
+  subscription_set_.insert(target);
+  const gpu::ValueState* state = pending_valuebuffer_state_->GetState(target);
+  if (state) {
+    SendUpdateValueState(target, *state);
+  }
+}
+
+void RenderWidgetHostImpl::OnRemoveSubscription(unsigned int target) {
+  subscription_set_.erase(target);
+}
+
 BrowserAccessibilityManager*
     RenderWidgetHostImpl::GetRootBrowserAccessibilityManager() {
   return delegate_ ? delegate_->GetRootBrowserAccessibilityManager() : NULL;
 }
 
 BrowserAccessibilityManager*
     RenderWidgetHostImpl::GetOrCreateRootBrowserAccessibilityManager() {
   return delegate_ ?
       delegate_->GetOrCreateRootBrowserAccessibilityManager() : NULL;
 }
 
 #if defined(OS_WIN)
 gfx::NativeViewAccessible
     RenderWidgetHostImpl::GetParentNativeViewAccessible() {
   return delegate_ ? delegate_->GetParentNativeViewAccessible() : NULL;
 }
 #endif
 
 SkColorType RenderWidgetHostImpl::PreferredReadbackFormat() {
   if (view_)
     return view_->PreferredReadbackFormat();
   return kN32_SkColorType;
 }
 
 }  // namespace content