Replace IPC messages in layout_test_render_frame_observer.

content/shell/renderer/layout_test/blink_test_runner.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/shell/renderer/layout_test/blink_test_runner.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <clocale>
@@ skipping 314 matching lines @@
   return base::TimeDelta(base::Time::Now() -
                          base::Time::UnixEpoch()).ToInternalValue() /
          base::Time::kMicrosecondsPerMillisecond;
 }
 
 WebString BlinkTestRunner::GetAbsoluteWebStringFromUTF8Path(
     const std::string& utf8_path) {
   base::FilePath path = base::FilePath::FromUTF8Unsafe(utf8_path);
   if (!path.IsAbsolute()) {
     GURL base_url =
-        net::FilePathToFileURL(test_config_.current_working_directory.Append(
+        net::FilePathToFileURL(test_config_->current_working_directory.Append(
             FILE_PATH_LITERAL("foo")));
     net::FileURLToFilePath(base_url.Resolve(utf8_path), &path);
   }
   return blink::FilePathToWebString(path);
 }
 
 WebURL BlinkTestRunner::LocalFileToDataURL(const WebURL& file_url) {
   base::FilePath local_path;
   if (!net::FileURLToFilePath(file_url, &local_path))
     return WebURL();
@@ skipping 210 matching lines @@
 }
 
 void BlinkTestRunner::SetBlockThirdPartyCookies(bool block) {
   Send(new LayoutTestHostMsg_BlockThirdPartyCookies(routing_id(), block));
 }
 
 std::string BlinkTestRunner::PathToLocalResource(const std::string& resource) {
 #if defined(OS_WIN)
   if (base::StartsWith(resource, "/tmp/", base::CompareCase::SENSITIVE)) {
     // We want a temp file.
-    GURL base_url = net::FilePathToFileURL(test_config_.temp_path);
+    GURL base_url = net::FilePathToFileURL(test_config_->temp_path);
     return base_url.Resolve(resource.substr(sizeof("/tmp/") - 1)).spec();
   }
 #endif
 
   // Some layout tests use file://// which we resolve as a UNC path. Normalize
   // them to just file:///.
   std::string result = resource;
   static const size_t kFileLen = sizeof("file:///") - 1;
   while (base::StartsWith(base::ToLowerASCII(result), "file:////",
                           base::CompareCase::SENSITIVE)) {
@@ skipping 59 matching lines @@
   Send(new ShellViewHostMsg_Reload(routing_id()));
 }
 
 void BlinkTestRunner::LoadURLForFrame(const WebURL& url,
                                       const std::string& frame_name) {
   Send(new ShellViewHostMsg_LoadURLForFrame(
       routing_id(), url, frame_name));
 }
 
 bool BlinkTestRunner::AllowExternalPages() {
-  return test_config_.allow_external_pages;
+  return test_config_->allow_external_pages;
 }
 
 std::string BlinkTestRunner::DumpHistoryForWindow(blink::WebView* web_view) {
   size_t pos = 0;
   std::vector<int>::iterator id;
   for (id = routing_ids_.begin(); id != routing_ids_.end(); ++id, ++pos) {
     RenderView* render_view = RenderView::FromRoutingID(*id);
     if (!render_view) {
       NOTREACHED();
       continue;
@@ skipping 232 matching lines @@
 
   Send(new ShellViewHostMsg_TextDump(routing_id(),
                                      std::move(completed_layout_dump)));
 
   CaptureDumpContinued();
 }
 
 void BlinkTestRunner::CaptureDumpContinued() {
   test_runner::WebTestInterfaces* interfaces =
       LayoutTestRenderThreadObserver::GetInstance()->test_interfaces();
-  if (test_config_.enable_pixel_dumping &&
+  if (test_config_->enable_pixel_dumping &&
       interfaces->TestRunner()->ShouldGeneratePixelResults() &&
       !interfaces->TestRunner()->ShouldDumpAsAudio()) {
     CHECK(render_view()->GetWebView()->isAcceleratedCompositingActive());
     interfaces->TestRunner()->DumpPixelsAsync(
         render_view()->GetWebView(),
         base::Bind(&BlinkTestRunner::OnPixelsDumpCompleted,
                    base::Unretained(this)));
     return;
   }
 
   CaptureDumpComplete();
 }
 
 void BlinkTestRunner::OnPixelsDumpCompleted(const SkBitmap& snapshot) {
   DCHECK_NE(0, snapshot.info().width());
   DCHECK_NE(0, snapshot.info().height());
 
   SkAutoLockPixels snapshot_lock(snapshot);
   // The snapshot arrives from the GPU process via shared memory. Because MSan
   // can't track initializedness across processes, we must assure it that the
   // pixels are in fact initialized.
   MSAN_UNPOISON(snapshot.getPixels(), snapshot.getSize());
   base::MD5Digest digest;
   base::MD5Sum(snapshot.getPixels(), snapshot.getSize(), &digest);
   std::string actual_pixel_hash = base::MD5DigestToBase16(digest);
 
-  if (actual_pixel_hash == test_config_.expected_pixel_hash) {
+  if (actual_pixel_hash == test_config_->expected_pixel_hash) {
     SkBitmap empty_image;
     Send(new ShellViewHostMsg_ImageDump(
         routing_id(), actual_pixel_hash, empty_image));
   } else {
     Send(new ShellViewHostMsg_ImageDump(
         routing_id(), actual_pixel_hash, snapshot));
   }
 
   CaptureDumpComplete();
 }
@@ skipping 17 matching lines @@
   DCHECK(!is_main_window_);
 
   test_runner::WebTestInterfaces* interfaces =
       LayoutTestRenderThreadObserver::GetInstance()->test_interfaces();
   interfaces->SetTestIsRunning(true);
   interfaces->ConfigureForTestWithURL(GURL(), false);
   ForceResizeRenderView(render_view(), WebSize(800, 600));
 }
 
 void BlinkTestRunner::OnReplicateTestConfiguration(
-    const ShellTestConfiguration& params) {
+    mojom::ShellTestConfigurationPtr params) {
   test_runner::WebTestInterfaces* interfaces =
       LayoutTestRenderThreadObserver::GetInstance()->test_interfaces();
 
-  test_config_ = params;
+  test_config_ = params.Clone();
 
   is_main_window_ = true;
   interfaces->SetMainView(render_view()->GetWebView());
 
   interfaces->SetTestIsRunning(true);
-  interfaces->ConfigureForTestWithURL(params.test_url,
-                                      params.enable_pixel_dumping);
+  interfaces->ConfigureForTestWithURL(params->test_url,
+                                      params->enable_pixel_dumping);
 }
 
 void BlinkTestRunner::OnSetTestConfiguration(
-    const ShellTestConfiguration& params) {
-  OnReplicateTestConfiguration(params);
+    mojom::ShellTestConfigurationPtr params) {
+  mojom::ShellTestConfigurationPtr local_params = params.Clone();
+  OnReplicateTestConfiguration(std::move(params));
 
-  ForceResizeRenderView(
-      render_view(),
-      WebSize(params.initial_size.width(), params.initial_size.height()));
+  ForceResizeRenderView(render_view(),
+                        WebSize(local_params->initial_size.width(),
+                                local_params->initial_size.height()));
   LayoutTestRenderThreadObserver::GetInstance()
       ->test_interfaces()
       ->TestRunner()
       ->SetFocus(render_view()->GetWebView(), true);
 }
 
 void BlinkTestRunner::OnSessionHistory(
     const std::vector<int>& routing_ids,
     const std::vector<std::vector<PageState>>& session_histories,
     const std::vector<unsigned>& current_entry_indexes) {
@@ skipping 39 matching lines @@
 void BlinkTestRunner::ReportLeakDetectionResult(
     const LeakDetectionResult& report) {
   Send(new ShellViewHostMsg_LeakDetectionDone(routing_id(), report));
 }
 
 void BlinkTestRunner::OnDestruct() {
   delete this;
 }
 
 }  // namespace content