[PPAPI] Add browser tests for compositor API

content/renderer/pepper/pepper_plugin_instance_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/pepper_plugin_instance_impl.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 1859 matching lines @@
     bool flash_fullscreen) {
   bool is_mouselock_pending = TrackedCallback::IsPending(lock_mouse_callback_);
 
   if (flash_fullscreen == flash_fullscreen_) {
     // Manually clear callback when fullscreen fails with mouselock pending.
     if (!flash_fullscreen && is_mouselock_pending)
       lock_mouse_callback_->Run(PP_ERROR_FAILED);
     return;
   }
 
-  UpdateLayer();
+  UpdateLayer(false);
 
   bool old_plugin_focus = PluginHasFocus();
   flash_fullscreen_ = flash_fullscreen;
   if (is_mouselock_pending && !IsMouseLocked()) {
     if (!IsProcessingUserGesture() &&
         !module_->permissions().HasPermission(
             ppapi::PERMISSION_BYPASS_USER_GESTURE)) {
       lock_mouse_callback_->Run(PP_ERROR_NO_USER_GESTURE);
     } else {
       // Open a user gesture here so the Webkit user gesture checks will succeed
@@ skipping 118 matching lines @@
     skia::EndPlatformPaint(canvas);
   }
 #endif  // defined(OS_WIN)
 
   return ret;
 #else  // defined(ENABLE_FULL_PRINTING)
   return false;
 #endif
 }
 
-void PepperPluginInstanceImpl::UpdateLayer() {
+void PepperPluginInstanceImpl::UpdateLayer(bool device_changed) {
   if (!container_)
     return;
 
   gpu::Mailbox mailbox;
   uint32 sync_point = 0;
   if (bound_graphics_3d_.get()) {
     bound_graphics_3d_->GetBackingMailbox(&mailbox, &sync_point);
     DCHECK_EQ(mailbox.IsZero(), sync_point == 0);
   }
   bool want_3d_layer = !mailbox.IsZero();
   bool want_2d_layer = !!bound_graphics_2d_platform_;
   bool want_texture_layer = want_3d_layer || want_2d_layer;
   bool want_compositor_layer = !!bound_compositor_;
 
-  if ((want_texture_layer == !!texture_layer_.get()) &&
+  if (!device_changed &&
+      (want_texture_layer == !!texture_layer_.get()) &&
       (want_3d_layer == layer_is_hardware_) &&
       (want_compositor_layer == !!compositor_layer_) &&
       layer_bound_to_fullscreen_ == !!fullscreen_container_) {
     UpdateLayerTransform();
     return;
   }
 
   if (texture_layer_ || compositor_layer_) {
     if (!layer_bound_to_fullscreen_)
       container_->setWebLayer(NULL);
@@ skipping 220 matching lines @@
     bound_graphics_2d_platform_->BindToInstance(NULL);
     bound_graphics_2d_platform_ = NULL;
   }
   if (bound_compositor_) {
     bound_compositor_->BindToInstance(NULL);
     bound_compositor_ = NULL;
   }
 
   // Special-case clearing the current device.
   if (!device) {
-    UpdateLayer();
+    UpdateLayer(true);
     InvalidateRect(gfx::Rect());
     return PP_TRUE;
   }
 
   // Refuse to bind if in transition to fullscreen with PPB_FlashFullscreen or
   // to/from fullscreen with PPB_Fullscreen.
   if ((fullscreen_container_ && !flash_fullscreen_) ||
       desired_fullscreen_state_ != view_data_.is_fullscreen)
     return PP_FALSE;
 
@@ skipping 15 matching lines @@
 
   EnterResourceNoLock<PPB_Graphics3D_API> enter_3d(device, false);
   PPB_Graphics3D_Impl* graphics_3d =
       enter_3d.succeeded()
           ? static_cast<PPB_Graphics3D_Impl*>(enter_3d.object())
           : NULL;
 
   if (compositor) {
     if (compositor->BindToInstance(this)) {
       bound_compositor_ = compositor;
-      UpdateLayer();
+      UpdateLayer(true);
       return PP_TRUE;
     }
   } else if (graphics_2d) {
     if (graphics_2d->BindToInstance(this)) {
       bound_graphics_2d_platform_ = graphics_2d;
-      UpdateLayer();
+      UpdateLayer(true);
       return PP_TRUE;
     }
   } else if (graphics_3d) {
     // Make sure graphics can only be bound to the instance it is
     // associated with.
     if (graphics_3d->pp_instance() == pp_instance() &&
         graphics_3d->BindToInstance(true)) {
       bound_graphics_3d_ = graphics_3d;
-      UpdateLayer();
+      UpdateLayer(true);
       return PP_TRUE;
     }
   }
 
   // The instance cannot be bound or the device is not a valid resource type.
   return PP_FALSE;
 }
 
 PP_Bool PepperPluginInstanceImpl::IsFullFrame(PP_Instance instance) {
   return PP_FromBool(full_frame());
@@ skipping 750 matching lines @@
                          ->renderer_preferences()
                          .plugin_fullscreen_allowed)
     return false;
 
   // Unbind current 2D or 3D graphics context.
   VLOG(1) << "Setting fullscreen to " << (fullscreen ? "on" : "off");
   if (fullscreen) {
     DCHECK(!fullscreen_container_);
     fullscreen_container_ =
         render_frame_->CreatePepperFullscreenContainer(this);
-    UpdateLayer();
+    UpdateLayer(false);
   } else {
     DCHECK(fullscreen_container_);
     fullscreen_container_->Destroy();
     fullscreen_container_ = NULL;
     UpdateFlashFullscreenState(false);
     if (!delay_report) {
       ReportGeometry();
     } else {
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
@@ skipping 197 matching lines @@
     // Running out-of-process. Initiate an IPC call to notify the plugin
     // process.
     ppapi::proxy::HostDispatcher* dispatcher =
         ppapi::proxy::HostDispatcher::GetForInstance(pp_instance());
     dispatcher->Send(new PpapiMsg_PPPInstance_HandleDocumentLoad(
         ppapi::API_ID_PPP_INSTANCE, pp_instance(), pending_host_id, data));
   }
 }
 
 }  // namespace content