Make lost context and error message callbacks on GpuControl go to client

content/renderer/pepper/ppb_graphics_3d_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/renderer/pepper/ppb_graphics_3d_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 27 matching lines @@
 
 namespace content {
 
 PPB_Graphics3D_Impl::PPB_Graphics3D_Impl(PP_Instance instance)
     : PPB_Graphics3D_Shared(instance),
       bound_to_instance_(false),
       commit_pending_(false),
       has_alpha_(false),
       weak_ptr_factory_(this) {}
 
-PPB_Graphics3D_Impl::~PPB_Graphics3D_Impl() {}
+PPB_Graphics3D_Impl::~PPB_Graphics3D_Impl() {
+  command_buffer_->SetGpuControlClient(nullptr);
+}
 
 // static
 PP_Resource PPB_Graphics3D_Impl::CreateRaw(
     PP_Instance instance,
     PP_Resource share_context,
     const int32_t* attrib_list,
     gpu::Capabilities* capabilities,
     base::SharedMemoryHandle* shared_state_handle,
     gpu::CommandBufferId* command_buffer_id) {
   PPB_Graphics3D_API* share_api = NULL;
@@ skipping 178 matching lines @@
     share_buffer = share_graphics->GetCommandBufferProxy();
   }
 
   command_buffer_ = channel_->CreateCommandBuffer(
       gpu::kNullSurfaceHandle, surface_size, share_buffer,
       gpu::GpuChannelHost::kDefaultStreamId,
       gpu::GpuChannelHost::kDefaultStreamPriority, attribs, GURL::EmptyGURL(),
       gpu_preference);
   if (!command_buffer_)
     return false;
+
+  command_buffer_->SetGpuControlClient(this);
+
   if (!command_buffer_->Initialize())
     return false;
+
   if (shared_state_handle)
     *shared_state_handle = command_buffer_->GetSharedStateHandle();
   if (capabilities)
     *capabilities = command_buffer_->GetCapabilities();
   if (command_buffer_id)
     *command_buffer_id = command_buffer_->GetCommandBufferID();
+
   mailbox_ = gpu::Mailbox::Generate();
   if (!command_buffer_->ProduceFrontBuffer(mailbox_))
     return false;
 
-  command_buffer_->SetContextLostCallback(base::Bind(
-      &PPB_Graphics3D_Impl::OnContextLost, weak_ptr_factory_.GetWeakPtr()));
-
-  command_buffer_->SetOnConsoleMessageCallback(base::Bind(
-      &PPB_Graphics3D_Impl::OnConsoleMessage, weak_ptr_factory_.GetWeakPtr()));
   return true;
 }
 
-void PPB_Graphics3D_Impl::OnConsoleMessage(const std::string& message, int id) {
+void PPB_Graphics3D_Impl::OnGpuControlErrorMessage(const char* message,
+                                                   int32_t id) {
   if (!bound_to_instance_)
     return;
   WebPluginContainer* container =
       HostGlobals::Get()->GetInstance(pp_instance())->container();
   if (!container)
     return;
   WebLocalFrame* frame = container->element().document().frame();
   if (!frame)
     return;
   WebConsoleMessage console_message = WebConsoleMessage(
       WebConsoleMessage::LevelError, WebString(base::UTF8ToUTF16(message)));
   frame->addMessageToConsole(console_message);
 }
 
-void PPB_Graphics3D_Impl::OnSwapBuffers() {
-  if (HasPendingSwap()) {
-    // If we're off-screen, no need to trigger and wait for compositing.
-    // Just send the swap-buffers ACK to the plugin immediately.
-    commit_pending_ = false;
-    SwapBuffersACK(PP_OK);
-  }
-}
+void PPB_Graphics3D_Impl::OnGpuControlLostContext() {
+#if DCHECK_IS_ON()
+  // This should never occur more than once.
+  DCHECK(!lost_context_);
+  lost_context_ = true;
+#endif
 
-void PPB_Graphics3D_Impl::OnContextLost() {
-  // Don't need to check for NULL from GetPluginInstance since when we're
+  // Don't need to check for null from GetPluginInstance since when we're
   // bound, we know our instance is valid.
   if (bound_to_instance_) {
     HostGlobals::Get()->GetInstance(pp_instance())->BindGraphics(pp_instance(),
                                                                  0);
   }
 
   // Send context lost to plugin. This may have been caused by a PPAPI call, so
   // avoid re-entering.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&PPB_Graphics3D_Impl::SendContextLost,
                             weak_ptr_factory_.GetWeakPtr()));
 }
 
+void PPB_Graphics3D_Impl::OnSwapBuffers() {
+  if (HasPendingSwap()) {
+    // If we're off-screen, no need to trigger and wait for compositing.
+    // Just send the swap-buffers ACK to the plugin immediately.
+    commit_pending_ = false;
+    SwapBuffersACK(PP_OK);
+  }
+}
+
 void PPB_Graphics3D_Impl::SendContextLost() {
   // By the time we run this, the instance may have been deleted, or in the
   // process of being deleted. Even in the latter case, we don't want to send a
   // callback after DidDestroy.
   PepperPluginInstanceImpl* instance =
       HostGlobals::Get()->GetInstance(pp_instance());
   if (!instance || !instance->container())
     return;
 
   // This PPB_Graphics3D_Impl could be deleted during the call to
   // GetPluginInterface (which sends a sync message in some cases). We still
   // send the Graphics3DContextLost to the plugin; the instance may care about
   // that event even though this context has been destroyed.
   PP_Instance this_pp_instance = pp_instance();
   const PPP_Graphics3D* ppp_graphics_3d = static_cast<const PPP_Graphics3D*>(
       instance->module()->GetPluginInterface(PPP_GRAPHICS_3D_INTERFACE));
   // We have to check *again* that the instance exists, because it could have
   // been deleted during GetPluginInterface(). Even the PluginModule could be
   // deleted, but in that case, the instance should also be gone, so the
   // GetInstance check covers both cases.
   if (ppp_graphics_3d && HostGlobals::Get()->GetInstance(this_pp_instance))
     ppp_graphics_3d->Graphics3DContextLost(this_pp_instance);
 }
 
 }  // namespace content