OOPIF support for layout test pixel dumps.

content/shell/browser/layout_test/blink_test_controller.cc

 // Copyright 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/shell/browser/layout_test/blink_test_controller.h"
 
 #include <stddef.h>
 
 #include <iostream>
 #include <set>
@@ skipping 474 matching lines @@
 bool BlinkTestController::OnMessageReceived(const IPC::Message& message) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(BlinkTestController, message)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_PrintMessage, OnPrintMessage)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_PrintMessageToStderr,
                         OnPrintMessageToStderr)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_TextDump, OnTextDump)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_InitiateLayoutDump,
                         OnInitiateLayoutDump)
+    IPC_MESSAGE_HANDLER(ShellViewHostMsg_InitiatePixelsDump,
+                        OnInitiatePixelsDump)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_ImageDump, OnImageDump)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_AudioDump, OnAudioDump)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_OverridePreferences,
                         OnOverridePreferences)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_SetPopupBlockingEnabled,
                         OnSetPopupBlockingEnabled)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_TestFinished, OnTestFinished)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_ClearDevToolsLocalStorage,
                         OnClearDevToolsLocalStorage)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_ShowDevTools, OnShowDevTools)
@@ skipping 274 matching lines @@
 
     ++number_of_messages;
     GetLayoutTestControlPtr(rfh)->DumpFrameLayout(
         base::Bind(&BlinkTestController::OnDumpFrameLayoutResponse,
                    base::Unretained(this), rfh->GetFrameTreeNodeId()));
   }
 
   pending_layout_dumps_ = number_of_messages;
 }
 
+void BlinkTestController::OnInitiatePixelsDump() {
+  // DO NOT SUBMIT - remove ad-hoc logs.
+  LOG(ERROR) << "OnInitiatePixelsDump";
+  composited_frames_.clear();
+  TriggerCompositingIfAllChildrenHaveBeenComposited();
+}
+
+void BlinkTestController::TriggerCompositingIfAllChildrenHaveBeenComposited() {
+  for (RenderFrameHost* rfh : main_window_->web_contents()->GetAllFrames()) {
+    // Skip the frame if it already was composited.
+    if (0 != composited_frames_.count(rfh->GetFrameTreeNodeId()))
+      continue;
+
+    // Ignore non-live frames / pretend that they are ready for a pixel dump.
+    if (!rfh->IsRenderFrameLive()) {
+      composited_frames_.insert(rfh->GetFrameTreeNodeId());
+      continue;
+    }
+
+    // Check if all child frames of |rfh| have been composited.
+    bool are_all_children_composited = true;
+    for (RenderFrameHost* child :
+         main_window_->web_contents()->GetAllFrames()) {
+      if (child->GetParent() != rfh)
+        continue;
+      if (0 == composited_frames_.count(child->GetFrameTreeNodeId())) {
+        are_all_children_composited = false;
+        break;
+      }
+    }
+    if (!are_all_children_composited)
+      continue;
+
+    // At this point we know that |rfh| is ready for compositing.
+    TriggerCompositing(rfh);
+  }
+}
+
+void BlinkTestController::TriggerCompositing(RenderFrameHost* frame) {
+  LOG(ERROR) << "TriggerCompositing"
+             << "; frame->GetLastCommittedURL() = "
+             << frame->GetLastCommittedURL();
+
+  GetLayoutTestControlPtr(frame)->TriggerCompositing(
+      base::Bind(&BlinkTestController::OnTriggerCompositingResponse,
+                 base::Unretained(this), frame->GetFrameTreeNodeId(),
+                 frame->GetProcess()->GetID()));
+}
+
+void BlinkTestController::OnTriggerCompositingResponse(
+    int frame_tree_node_id,
+    // DO NOT SUBMIT - use |process_id|?
+    int process_id) {
+  LOG(ERROR) << "OnTriggerCompositingResponse";
+  composited_frames_.insert(frame_tree_node_id);
+
+  if (0 ==
+      composited_frames_.count(
+          main_window_->web_contents()->GetMainFrame()->GetFrameTreeNodeId())) {
+    TriggerCompositingIfAllChildrenHaveBeenComposited();
+    return;
+  }
+
+  LOG(ERROR) << "OnTriggerCompositingResponse - all frames were composited";
+  main_window_->web_contents()->GetRenderWidgetHostView()->CopyFromSurface(
+      gfx::Rect(), gfx::Size(),
+      base::Bind(&BlinkTestController::OnPixelsDumpCaptured,
+                 base::Unretained(this)),
+      kN32_SkColorType);
+}
+
 void BlinkTestController::OnLayoutTestRuntimeFlagsChanged(
     int sender_process_host_id,
     const base::DictionaryValue& changed_layout_test_runtime_flags) {
   // Stash the accumulated changes for future, not-yet-created renderers.
   accumulated_layout_test_runtime_flags_changes_.MergeDictionary(
       &changed_layout_test_runtime_flags);
 
   // Propagate the changes to all the tracked renderer processes.
   for (RenderProcessHost* process : all_observed_render_process_hosts_) {
     // Do not propagate the changes back to the process that originated them.
@@ skipping 32 matching lines @@
     }
   }
 
   // Continue finishing the test.
   RenderViewHost* render_view_host =
       main_window_->web_contents()->GetRenderViewHost();
   render_view_host->Send(new ShellViewMsg_LayoutDumpCompleted(
       render_view_host->GetRoutingID(), stitched_layout_dump));
 }
 
+void BlinkTestController::OnPixelsDumpCaptured(const SkBitmap& dump,
+                                               ReadbackResponse response) {
+  DCHECK_EQ(READBACK_SUCCESS, response);
+  RenderViewHost* render_view_host =
+      main_window_->web_contents()->GetRenderViewHost();
+  render_view_host->Send(new ShellViewMsg_PixelsDumpResult(
+      render_view_host->GetRoutingID(), dump));
+}
+
 void BlinkTestController::OnPrintMessage(const std::string& message) {
   printer_->AddMessageRaw(message);
 }
 
 void BlinkTestController::OnPrintMessageToStderr(const std::string& message) {
   printer_->AddMessageToStderr(message);
 }
 
 void BlinkTestController::OnOverridePreferences(const WebPreferences& prefs) {
   should_override_prefs_ = true;
@@ skipping 194 matching lines @@
   }
   DCHECK(layout_test_control_map_[frame].get());
   return layout_test_control_map_[frame].get();
 }
 
 void BlinkTestController::HandleLayoutTestControlError(RenderFrameHost* frame) {
   layout_test_control_map_.erase(frame);
 }
 
 }  // namespace content