Redesigned CommandBuffer and NPDevice3D interfaces

chrome/renderer/webplugin_delegate_pepper.cc

 // Copyright (c) 2009 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.
 
 #define PEPPER_APIS_ENABLED 1
 
 #include "chrome/renderer/webplugin_delegate_pepper.h"
 
 #include <string>
 #include <vector>
@@ skipping 334 matching lines @@
                                    std::vector<std::string>(),
                                    plugin_,
                                    false)) {
     plugin_->SetAcceptsInputEvents(true);
 
     // Ask the GPU plugin to create a command buffer and return a proxy.
     command_buffer_.reset(nested_delegate_->CreateCommandBuffer());
     if (command_buffer_.get()) {
       // Initialize the proxy command buffer.
       if (command_buffer_->Initialize(config->commandBufferEntries)) {
+        // Get the initial command buffer state.
+        gpu::CommandBuffer::State state = command_buffer_->GetState();
+
         // Initialize the 3D context.
         context->reserved = NULL;
         Buffer ring_buffer = command_buffer_->GetRingBuffer();
         context->commandBuffer = ring_buffer.ptr;
-        context->commandBufferEntries = command_buffer_->GetSize();
-        context->getOffset = command_buffer_->GetGetOffset();
-        context->putOffset = command_buffer_->GetPutOffset();
+        context->commandBufferEntries = state.size;
+        Synchronize3DContext(context, state);
 
         // Ensure the service knows the window size before rendering anything.
         nested_delegate_->UpdateGeometry(window_rect_, clip_rect_);
         // Save the implementation information (the CommandBuffer).
         Device3DImpl* impl = new Device3DImpl;
         impl->command_buffer = command_buffer_.get();
         context->reserved = impl;
 
         return NPERR_NO_ERROR;
       }
@@ skipping 13 matching lines @@
     NPDeviceContext3D* context,
     int32 state,
     int32 value) {
   return NPERR_GENERIC_ERROR;
 }
 
 NPError WebPluginDelegatePepper::Device3DGetStateContext(
     NPDeviceContext3D* context,
     int32 state,
     int32* value) {
-#if defined(ENABLE_GPU)
-  if (!command_buffer_.get())
-    return NPERR_GENERIC_ERROR;
-
-  switch (state) {
-    case NPDeviceContext3DState_GetOffset:
-      context->getOffset = *value = command_buffer_->GetGetOffset();
-      break;
-    case NPDeviceContext3DState_PutOffset:
-      *value = command_buffer_->GetPutOffset();
-      break;
-    case NPDeviceContext3DState_Token:
-      *value = command_buffer_->GetToken();
-      break;
-    case NPDeviceContext3DState_ParseError:
-      *value = command_buffer_->ResetParseError();
-      break;
-    case NPDeviceContext3DState_ErrorStatus:
-      *value = command_buffer_->GetErrorStatus() ? 1 : 0;
-      break;
-    default:
-      return NPERR_GENERIC_ERROR;
-  };
-#endif  // ENABLE_GPU
-
-  return NPERR_NO_ERROR;
+  return NPERR_GENERIC_ERROR;
 }
 
 NPError WebPluginDelegatePepper::Device3DFlushContext(
     NPP id,
     NPDeviceContext3D* context,
     NPDeviceFlushContextCallbackPtr callback,
     void* user_data) {
 #if defined(ENABLE_GPU)
-  DCHECK(callback == NULL);
-  context->getOffset = command_buffer_->SyncOffsets(context->putOffset);
+  gpu::CommandBuffer::State state;
+  // Only flush if new commands have been put in the command buffer. Otherwise
+  // update the state to the current service state.
+  if (context->putOffset == last_command_buffer_put_offset_) {
+    state = command_buffer_->GetState();
+  } else {
+    last_command_buffer_put_offset_ = context->putOffset;
+    state = command_buffer_->Flush(context->putOffset);
+  }
+  Synchronize3DContext(context, state);
 #endif  // ENABLE_GPU
   return NPERR_NO_ERROR;
 }
 
 NPError WebPluginDelegatePepper::Device3DDestroyContext(
     NPDeviceContext3D* context) {
 #if defined(ENABLE_GPU)
   command_buffer_.reset();
 
   if (nested_delegate_) {
@@ skipping 108 matching lines @@
   memset(context, 0, sizeof(NPDeviceContextAudio));
   return NPERR_NO_ERROR;
 }
 
 WebPluginDelegatePepper::WebPluginDelegatePepper(
     const base::WeakPtr<RenderView>& render_view,
     NPAPI::PluginInstance *instance)
     : render_view_(render_view),
       plugin_(NULL),
       instance_(instance),
-      nested_delegate_(NULL) {
+      nested_delegate_(NULL),
+      last_command_buffer_put_offset_(-1) {
   // For now we keep a window struct, although it isn't used.
   memset(&window_, 0, sizeof(window_));
   // All Pepper plugins are windowless and transparent.
   // TODO(sehr): disable resetting these NPPVs by plugins.
   instance->set_windowless(true);
   instance->set_transparent(true);
 }
 
 WebPluginDelegatePepper::~WebPluginDelegatePepper() {
   DestroyInstance();
@@ skipping 143 matching lines @@
       BuildCharEvent(&event, &npevent);
       break;
     case NPEventType_Minimize:
     case NPEventType_Focus:
     case NPEventType_Device:
       // NOTIMPLEMENTED();
       break;
   }
   return instance()->NPP_HandleEvent(&npevent) != 0;
 }
+
+#if defined(ENABLE_GPU)
+void WebPluginDelegatePepper::Synchronize3DContext(
+    NPDeviceContext3D* context,
+    gpu::CommandBuffer::State state) {
+  context->getOffset = state.get_offset;
+  context->putOffset = state.put_offset;
+  context->token = state.token;
+  context->error = static_cast<int32>(state.error);
+}
+#endif  // ENABLE_GPU