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 226 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()));

[no sievers, 2016/04/08 18:11:45]

Unlike PepeprVideoEncoderHost, here the WeakPtr factory invalidates before the
command_buffer_ is destroyed. But as long as there is no reentrancy from the
callback in the destructor, which looks like it should never happen, we're good.
But maybe SetGpuControlClient(null) in the destructor to be paranoid.

[danakj, 2016/04/08 18:38:58]

Sure, done.

   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