Fix <webview> with software compositor

content/renderer/browser_plugin/browser_plugin_compositing_helper.cc

 // Copyright (c) 2013 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/browser_plugin/browser_plugin_compositing_helper.h"
 
 #include "cc/layers/delegated_renderer_layer.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/layers/texture_layer.h"
 #include "cc/output/context_provider.h"
@@ skipping 23 matching lines @@
     BrowserPluginManager* manager,
     int instance_id,
     int host_routing_id)
     : instance_id_(instance_id),
       host_routing_id_(host_routing_id),
       last_route_id_(0),
       last_output_surface_id_(0),
       last_host_id_(0),
       last_mailbox_valid_(false),
       ack_pending_(true),
+      software_ack_pending_(false),
       container_(container),
       browser_plugin_manager_(manager) {
 }
 
 BrowserPluginCompositingHelper::~BrowserPluginCompositingHelper() {
 }
 
 void BrowserPluginCompositingHelper::DidCommitCompositorFrame() {
+  if (software_ack_pending_) {
+    cc::CompositorFrameAck ack;
+    if (!unacked_software_frames_.empty()) {
+      ack.last_software_frame_id = unacked_software_frames_.back();
+      unacked_software_frames_.pop_back();
+    }
+
+    browser_plugin_manager_->Send(
+        new BrowserPluginHostMsg_CompositorFrameACK(
+            host_routing_id_,
+            instance_id_,
+            last_route_id_,
+            last_output_surface_id_,
+            last_host_id_,
+            ack));
+
+    software_ack_pending_ = false;
+  }
   if (!delegated_layer_.get() || !ack_pending_)
     return;
 
   cc::CompositorFrameAck ack;
   delegated_layer_->TakeUnusedResourcesForChildCompositor(&ack.resources);
 
   browser_plugin_manager_->Send(
       new BrowserPluginHostMsg_CompositorFrameACK(
           host_routing_id_,
           instance_id_,
@@ skipping 43 matching lines @@
     // Reset mailbox's name if the resource was lost.
     mailbox.name.SetZero();
   }
 
   // This means the GPU process crashed or guest crashed.
   if (last_host_id_ != mailbox.host_id ||
       last_output_surface_id_ != mailbox.output_surface_id ||
       last_route_id_ != mailbox.route_id)
     return;
 
+  if (mailbox.type == SOFTWARE_COMPOSITOR_FRAME)
+    unacked_software_frames_.push_back(mailbox.software_frame_id);
+
   // We need to send an ACK to for every buffer sent to us.
   // However, if a buffer is freed up from
   // the compositor in cases like switching back to SW mode without a new
   // buffer arriving, no ACK is needed.
   if (!ack_pending_) {
     last_mailbox_valid_ = false;
     return;
   }
   ack_pending_ = false;
   switch (mailbox.type) {
@@ skipping 20 matching lines @@
       browser_plugin_manager_->Send(
          new BrowserPluginHostMsg_CompositorFrameACK(
              host_routing_id_,
              instance_id_,
              mailbox.route_id,
              mailbox.output_surface_id,
              mailbox.host_id,
              ack));
       break;
     }
-    case SOFTWARE_COMPOSITOR_FRAME: {
-      cc::CompositorFrameAck ack;
-      ack.last_software_frame_id = mailbox.software_frame_id;
-
-      browser_plugin_manager_->Send(
-         new BrowserPluginHostMsg_CompositorFrameACK(
-             host_routing_id_,
-             instance_id_,
-             mailbox.route_id,
-             mailbox.output_surface_id,
-             mailbox.host_id,
-             ack));
+    case SOFTWARE_COMPOSITOR_FRAME:
       break;
-    }
   }
 }
 
 void BrowserPluginCompositingHelper::OnContainerDestroy() {
   if (container_)
     container_->setWebLayer(NULL);
   container_ = NULL;
 
   texture_layer_ = NULL;
   delegated_layer_ = NULL;
@@ skipping 124 matching lines @@
     swap_info.host_id = host_id;
     swap_info.software_frame_id = frame_data->id;
 
     scoped_ptr<base::SharedMemory> shared_memory(
         new base::SharedMemory(frame_data->handle, true));
     const size_t size_in_bytes = 4 * frame_data->size.GetArea();
     if (!shared_memory->Map(size_in_bytes)) {
       LOG(ERROR) << "Failed to map shared memory of size "
                  << size_in_bytes;
       // Send ACK right away.
-      ack_pending_ = true;
+      software_ack_pending_ = true;
       MailboxReleased(swap_info, 0, false);
+      DidCommitCompositorFrame();
       return;
     }
 
     swap_info.shared_memory = shared_memory.release();
     OnBuffersSwappedPrivate(swap_info, 0,
                             frame->metadata.device_scale_factor);
+    software_ack_pending_ = true;
+    last_route_id_ = route_id;
+    last_output_surface_id_ = output_surface_id;
+    last_host_id_ = host_id;
     return;
   }
 
   DCHECK(!texture_layer_.get());
   if (!delegated_layer_.get()) {
     delegated_layer_ = cc::DelegatedRendererLayer::Create(NULL);
     delegated_layer_->SetIsDrawable(true);
     delegated_layer_->SetContentsOpaque(true);
 
     background_layer_->AddChild(delegated_layer_);
@@ skipping 16 matching lines @@
 }
 
 void BrowserPluginCompositingHelper::UpdateVisibility(bool visible) {
   if (texture_layer_.get())
     texture_layer_->SetIsDrawable(visible);
   if (delegated_layer_.get())
     delegated_layer_->SetIsDrawable(visible);
 }
 
 }  // namespace content