content: Rename WebKitTestController to BlinkTestController.

content/shell/browser/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/webkit_test_controller.h"
+#include "content/shell/browser/blink_test_controller.h"
 
 #include <iostream>
 
 #include "base/base64.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "content/public/browser/devtools_agent_host.h"
@@ skipping 18 matching lines @@
 #include "content/shell/common/shell_messages.h"
 #include "content/shell/common/shell_switches.h"
 #include "content/shell/common/webkit_test_helpers.h"
 #include "ui/gfx/codec/png_codec.h"
 
 namespace content {
 
 const int kTestSVGWindowWidthDip = 480;
 const int kTestSVGWindowHeightDip = 360;
 
-// WebKitTestResultPrinter ----------------------------------------------------
+// BlinkTestResultPrinter ----------------------------------------------------
 
-WebKitTestResultPrinter::WebKitTestResultPrinter(
-    std::ostream* output, std::ostream* error)
+BlinkTestResultPrinter::BlinkTestResultPrinter(std::ostream* output,
+                                               std::ostream* error)
     : state_(DURING_TEST),
       capture_text_only_(false),
       encode_binary_data_(false),
       output_(output),
       error_(error) {
 }
 
-WebKitTestResultPrinter::~WebKitTestResultPrinter() {
+BlinkTestResultPrinter::~BlinkTestResultPrinter() {
 }
 
-void WebKitTestResultPrinter::PrintTextHeader() {
+void BlinkTestResultPrinter::PrintTextHeader() {
   if (state_ != DURING_TEST)
     return;
   if (!capture_text_only_)
     *output_ << "Content-Type: text/plain\n";
   state_ = IN_TEXT_BLOCK;
 }
 
-void WebKitTestResultPrinter::PrintTextBlock(const std::string& block) {
+void BlinkTestResultPrinter::PrintTextBlock(const std::string& block) {
   if (state_ != IN_TEXT_BLOCK)
     return;
   *output_ << block;
 }
 
-void WebKitTestResultPrinter::PrintTextFooter() {
+void BlinkTestResultPrinter::PrintTextFooter() {
   if (state_ != IN_TEXT_BLOCK)
     return;
   if (!capture_text_only_) {
     *output_ << "#EOF\n";
     output_->flush();
   }
   state_ = IN_IMAGE_BLOCK;
 }
 
-void WebKitTestResultPrinter::PrintImageHeader(
+void BlinkTestResultPrinter::PrintImageHeader(
     const std::string& actual_hash,
     const std::string& expected_hash) {
   if (state_ != IN_IMAGE_BLOCK || capture_text_only_)
     return;
   *output_ << "\nActualHash: " << actual_hash << "\n";
   if (!expected_hash.empty())
     *output_ << "\nExpectedHash: " << expected_hash << "\n";
 }
 
-void WebKitTestResultPrinter::PrintImageBlock(
+void BlinkTestResultPrinter::PrintImageBlock(
     const std::vector<unsigned char>& png_image) {
   if (state_ != IN_IMAGE_BLOCK || capture_text_only_)
     return;
   *output_ << "Content-Type: image/png\n";
   if (encode_binary_data_) {
     PrintEncodedBinaryData(png_image);
     return;
   }
 
   *output_ << "Content-Length: " << png_image.size() << "\n";
   output_->write(
       reinterpret_cast<const char*>(&png_image[0]), png_image.size());
 }
 
-void WebKitTestResultPrinter::PrintImageFooter() {
+void BlinkTestResultPrinter::PrintImageFooter() {
   if (state_ != IN_IMAGE_BLOCK)
     return;
   if (!capture_text_only_) {
     *output_ << "#EOF\n";
     output_->flush();
   }
   state_ = AFTER_TEST;
 }
 
-void WebKitTestResultPrinter::PrintAudioHeader() {
+void BlinkTestResultPrinter::PrintAudioHeader() {
   DCHECK_EQ(state_, DURING_TEST);
   if (!capture_text_only_)
     *output_ << "Content-Type: audio/wav\n";
   state_ = IN_AUDIO_BLOCK;
 }
 
-void WebKitTestResultPrinter::PrintAudioBlock(
+void BlinkTestResultPrinter::PrintAudioBlock(
     const std::vector<unsigned char>& audio_data) {
   if (state_ != IN_AUDIO_BLOCK || capture_text_only_)
     return;
   if (encode_binary_data_) {
     PrintEncodedBinaryData(audio_data);
     return;
   }
 
   *output_ << "Content-Length: " << audio_data.size() << "\n";
   output_->write(
       reinterpret_cast<const char*>(&audio_data[0]), audio_data.size());
 }
 
-void WebKitTestResultPrinter::PrintAudioFooter() {
+void BlinkTestResultPrinter::PrintAudioFooter() {
   if (state_ != IN_AUDIO_BLOCK)
     return;
   if (!capture_text_only_) {
     *output_ << "#EOF\n";
     output_->flush();
   }
   state_ = IN_IMAGE_BLOCK;
 }
 
-void WebKitTestResultPrinter::AddMessage(const std::string& message) {
+void BlinkTestResultPrinter::AddMessage(const std::string& message) {
   AddMessageRaw(message + "\n");
 }
 
-void WebKitTestResultPrinter::AddMessageRaw(const std::string& message) {
+void BlinkTestResultPrinter::AddMessageRaw(const std::string& message) {
   if (state_ != DURING_TEST)
     return;
   *output_ << message;
 }
 
-void WebKitTestResultPrinter::AddErrorMessage(const std::string& message) {
+void BlinkTestResultPrinter::AddErrorMessage(const std::string& message) {
   if (!capture_text_only_)
     *error_ << message << "\n";
   if (state_ != DURING_TEST)
     return;
   PrintTextHeader();
   *output_ << message << "\n";
   PrintTextFooter();
   PrintImageFooter();
 }
 
-void WebKitTestResultPrinter::PrintEncodedBinaryData(
+void BlinkTestResultPrinter::PrintEncodedBinaryData(
     const std::vector<unsigned char>& data) {
   *output_ << "Content-Transfer-Encoding: base64\n";
 
   std::string data_base64;
   base::Base64Encode(
       base::StringPiece(reinterpret_cast<const char*>(&data[0]), data.size()),
       &data_base64);
 
   *output_ << "Content-Length: " << data_base64.length() << "\n";
   output_->write(data_base64.c_str(), data_base64.length());
 }
 
-void WebKitTestResultPrinter::CloseStderr() {
+void BlinkTestResultPrinter::CloseStderr() {
   if (state_ != AFTER_TEST)
     return;
   if (!capture_text_only_) {
     *error_ << "#EOF\n";
     error_->flush();
   }
 }
 
+// BlinkTestController -------------------------------------------------------
 
-// WebKitTestController -------------------------------------------------------
-
-WebKitTestController* WebKitTestController::instance_ = NULL;
+BlinkTestController* BlinkTestController::instance_ = NULL;
 
 // static
-WebKitTestController* WebKitTestController::Get() {
+BlinkTestController* BlinkTestController::Get() {
   DCHECK(instance_);
   return instance_;
 }
 
-WebKitTestController::WebKitTestController()
+BlinkTestController::BlinkTestController()
     : main_window_(NULL),
       test_phase_(BETWEEN_TESTS),
       is_leak_detection_enabled_(
           base::CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kEnableLeakDetection)),
       crash_when_leak_found_(false),
       devtools_frontend_(NULL) {
   CHECK(!instance_);
   instance_ = this;
 
   if (is_leak_detection_enabled_) {
     std::string switchValue =
         base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
             switches::kEnableLeakDetection);
     crash_when_leak_found_ = switchValue == switches::kCrashOnFailure;
   }
 
-  printer_.reset(new WebKitTestResultPrinter(&std::cout, &std::cerr));
+  printer_.reset(new BlinkTestResultPrinter(&std::cout, &std::cerr));
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEncodeBinary))
     printer_->set_encode_binary_data(true);
   registrar_.Add(this,
                  NOTIFICATION_RENDERER_PROCESS_CREATED,
                  NotificationService::AllSources());
   GpuDataManager::GetInstance()->AddObserver(this);
   ResetAfterLayoutTest();
 }
 
-WebKitTestController::~WebKitTestController() {
+BlinkTestController::~BlinkTestController() {
   DCHECK(CalledOnValidThread());
   CHECK(instance_ == this);
   CHECK(test_phase_ == BETWEEN_TESTS);
   GpuDataManager::GetInstance()->RemoveObserver(this);
   DiscardMainWindow();
   instance_ = NULL;
 }
 
-bool WebKitTestController::PrepareForLayoutTest(
+bool BlinkTestController::PrepareForLayoutTest(
     const GURL& test_url,
     const base::FilePath& current_working_directory,
     bool enable_pixel_dumping,
     const std::string& expected_pixel_hash) {
   DCHECK(CalledOnValidThread());
   test_phase_ = DURING_TEST;
   current_working_directory_ = current_working_directory;
   enable_pixel_dumping_ = enable_pixel_dumping;
   expected_pixel_hash_ = expected_pixel_hash;
   test_url_ = test_url;
@@ skipping 36 matching lines @@
         ui::PAGE_TRANSITION_TYPED | ui::PAGE_TRANSITION_FROM_ADDRESS_BAR);
     params.should_clear_history_list = true;
     main_window_->web_contents()->GetController().LoadURLWithParams(params);
     main_window_->web_contents()->Focus();
   }
   main_window_->web_contents()->GetRenderViewHost()->SetActive(true);
   main_window_->web_contents()->GetRenderViewHost()->Focus();
   return true;
 }
 
-bool WebKitTestController::ResetAfterLayoutTest() {
+bool BlinkTestController::ResetAfterLayoutTest() {
   DCHECK(CalledOnValidThread());
   printer_->PrintTextFooter();
   printer_->PrintImageFooter();
   printer_->CloseStderr();
   send_configuration_to_next_host_ = false;
   test_phase_ = BETWEEN_TESTS;
   is_compositing_test_ = false;
   enable_pixel_dumping_ = false;
   expected_pixel_hash_.clear();
   test_url_ = GURL();
   prefs_ = WebPreferences();
   should_override_prefs_ = false;
 
 #if defined(OS_ANDROID)
   // Re-using the shell's main window on Android causes issues with networking
   // requests never succeeding. See http://crbug.com/277652.
   DiscardMainWindow();
 #endif
   return true;
 }
 
-void WebKitTestController::SetTempPath(const base::FilePath& temp_path) {
+void BlinkTestController::SetTempPath(const base::FilePath& temp_path) {
   temp_path_ = temp_path;
 }
 
-void WebKitTestController::RendererUnresponsive() {
+void BlinkTestController::RendererUnresponsive() {
   DCHECK(CalledOnValidThread());
   LOG(WARNING) << "renderer unresponsive";
 }
 
-void WebKitTestController::WorkerCrashed() {
+void BlinkTestController::WorkerCrashed() {
   DCHECK(CalledOnValidThread());
   printer_->AddErrorMessage("#CRASHED - worker");
   DiscardMainWindow();
 }
 
-void WebKitTestController::OverrideWebkitPrefs(WebPreferences* prefs) {
+void BlinkTestController::OverrideWebkitPrefs(WebPreferences* prefs) {
   if (should_override_prefs_) {
     *prefs = prefs_;
   } else {
     ApplyLayoutTestDefaultPreferences(prefs);
     if (is_compositing_test_) {
       base::CommandLine& command_line = *base::CommandLine::ForCurrentProcess();
       if (!command_line.HasSwitch(switches::kDisableGpu))
         prefs->accelerated_2d_canvas_enabled = true;
       prefs->mock_scrollbars_enabled = true;
     }
   }
 }
 
-void WebKitTestController::OpenURL(const GURL& url) {
+void BlinkTestController::OpenURL(const GURL& url) {
   if (test_phase_ != DURING_TEST)
     return;
 
   Shell::CreateNewWindow(main_window_->web_contents()->GetBrowserContext(),
                          url,
                          main_window_->web_contents()->GetSiteInstance(),
                          gfx::Size());
 }
 
-void WebKitTestController::TestFinishedInSecondaryWindow() {
+void BlinkTestController::TestFinishedInSecondaryWindow() {
   RenderViewHost* render_view_host =
       main_window_->web_contents()->GetRenderViewHost();
   render_view_host->Send(
       new ShellViewMsg_NotifyDone(render_view_host->GetRoutingID()));
 }
 
-bool WebKitTestController::IsMainWindow(WebContents* web_contents) const {
+bool BlinkTestController::IsMainWindow(WebContents* web_contents) const {
   return main_window_ && web_contents == main_window_->web_contents();
 }
 
-bool WebKitTestController::OnMessageReceived(const IPC::Message& message) {
+bool BlinkTestController::OnMessageReceived(const IPC::Message& message) {
   DCHECK(CalledOnValidThread());
   bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)
+  IPC_BEGIN_MESSAGE_MAP(BlinkTestController, message)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_PrintMessage, OnPrintMessage)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_TextDump, OnTextDump)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_ImageDump, OnImageDump)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_AudioDump, OnAudioDump)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_OverridePreferences,
                         OnOverridePreferences)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_TestFinished, OnTestFinished)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_ClearDevToolsLocalStorage,
                         OnClearDevToolsLocalStorage)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_ShowDevTools, OnShowDevTools)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_CloseDevTools, OnCloseDevTools)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_GoToOffset, OnGoToOffset)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_Reload, OnReload)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_LoadURLForFrame, OnLoadURLForFrame)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_CaptureSessionHistory,
                         OnCaptureSessionHistory)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_CloseRemainingWindows,
                         OnCloseRemainingWindows)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_ResetDone, OnResetDone)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_LeakDetectionDone, OnLeakDetectionDone)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
-void WebKitTestController::PluginCrashed(const base::FilePath& plugin_path,
-                                         base::ProcessId plugin_pid) {
+void BlinkTestController::PluginCrashed(const base::FilePath& plugin_path,
+                                        base::ProcessId plugin_pid) {
   DCHECK(CalledOnValidThread());
   printer_->AddErrorMessage(
       base::StringPrintf("#CRASHED - plugin (pid %d)", plugin_pid));
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(base::IgnoreResult(&WebKitTestController::DiscardMainWindow),
+      base::Bind(base::IgnoreResult(&BlinkTestController::DiscardMainWindow),
                  base::Unretained(this)));
 }
 
-void WebKitTestController::RenderViewCreated(RenderViewHost* render_view_host) {
+void BlinkTestController::RenderViewCreated(RenderViewHost* render_view_host) {
   DCHECK(CalledOnValidThread());
   // Might be kNullProcessHandle, in which case we will receive a notification
   // later when the RenderProcessHost was created.
   if (render_view_host->GetProcess()->GetHandle() != base::kNullProcessHandle)
     current_pid_ = base::GetProcId(render_view_host->GetProcess()->GetHandle());
   if (!send_configuration_to_next_host_)
     return;
   send_configuration_to_next_host_ = false;
   SendTestConfiguration();
 }
 
-void WebKitTestController::RenderProcessGone(base::TerminationStatus status) {
+void BlinkTestController::RenderProcessGone(base::TerminationStatus status) {
   DCHECK(CalledOnValidThread());
   if (current_pid_ != base::kNullProcessId) {
     printer_->AddErrorMessage(std::string("#CRASHED - renderer (pid ") +
                               base::IntToString(current_pid_) + ")");
   } else {
     printer_->AddErrorMessage("#CRASHED - renderer");
   }
   DiscardMainWindow();
 }
 
-void WebKitTestController::DevToolsProcessCrashed() {
+void BlinkTestController::DevToolsProcessCrashed() {
   DCHECK(CalledOnValidThread());
   printer_->AddErrorMessage("#CRASHED - devtools");
   if (devtools_frontend_)
       devtools_frontend_->Close();
   devtools_frontend_ = NULL;
 }
 
-void WebKitTestController::WebContentsDestroyed() {
+void BlinkTestController::WebContentsDestroyed() {
   DCHECK(CalledOnValidThread());
   printer_->AddErrorMessage("FAIL: main window was destroyed");
   DiscardMainWindow();
 }
 
-void WebKitTestController::Observe(int type,
-                                   const NotificationSource& source,
-                                   const NotificationDetails& details) {
+void BlinkTestController::Observe(int type,
+                                  const NotificationSource& source,
+                                  const NotificationDetails& details) {
   DCHECK(CalledOnValidThread());
   switch (type) {
     case NOTIFICATION_RENDERER_PROCESS_CREATED: {
       if (!main_window_)
         return;
       RenderViewHost* render_view_host =
           main_window_->web_contents()->GetRenderViewHost();
       if (!render_view_host)
         return;
       RenderProcessHost* render_process_host =
           Source<RenderProcessHost>(source).ptr();
       if (render_process_host != render_view_host->GetProcess())
         return;
       current_pid_ = base::GetProcId(render_process_host->GetHandle());
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
-void WebKitTestController::OnGpuProcessCrashed(
+void BlinkTestController::OnGpuProcessCrashed(
     base::TerminationStatus exit_code) {
   DCHECK(CalledOnValidThread());
   printer_->AddErrorMessage("#CRASHED - gpu");
   DiscardMainWindow();
 }
 
-void WebKitTestController::DiscardMainWindow() {
+void BlinkTestController::DiscardMainWindow() {
   // If we're running a test, we need to close all windows and exit the message
   // loop. Otherwise, we're already outside of the message loop, and we just
   // discard the main window.
   WebContentsObserver::Observe(NULL);
   if (test_phase_ != BETWEEN_TESTS) {
     Shell::CloseAllWindows();
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::MessageLoop::QuitClosure());
     test_phase_ = CLEAN_UP;
   } else if (main_window_) {
     main_window_->Close();
   }
   main_window_ = NULL;
   current_pid_ = base::kNullProcessId;
 }
 
-void WebKitTestController::SendTestConfiguration() {
+void BlinkTestController::SendTestConfiguration() {
   RenderViewHost* render_view_host =
       main_window_->web_contents()->GetRenderViewHost();
   ShellTestConfiguration params;
   params.current_working_directory = current_working_directory_;
   params.temp_path = temp_path_;
   params.test_url = test_url_;
   params.enable_pixel_dumping = enable_pixel_dumping_;
   params.allow_external_pages =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAllowExternalPages);
   params.expected_pixel_hash = expected_pixel_hash_;
   params.initial_size = initial_size_;
   render_view_host->Send(new ShellViewMsg_SetTestConfiguration(
       render_view_host->GetRoutingID(), params));
 }
 
-void WebKitTestController::OnTestFinished() {
+void BlinkTestController::OnTestFinished() {
   test_phase_ = CLEAN_UP;
   if (!printer_->output_finished())
     printer_->PrintImageFooter();
   RenderViewHost* render_view_host =
       main_window_->web_contents()->GetRenderViewHost();
   main_window_->web_contents()->ExitFullscreen();
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(base::IgnoreResult(&WebKitTestController::Send),
+      base::Bind(base::IgnoreResult(&BlinkTestController::Send),
                  base::Unretained(this),
                  new ShellViewMsg_Reset(render_view_host->GetRoutingID())));
 }
 
-void WebKitTestController::OnImageDump(
-    const std::string& actual_pixel_hash,
-    const SkBitmap& image) {
+void BlinkTestController::OnImageDump(const std::string& actual_pixel_hash,
+                                      const SkBitmap& image) {
   SkAutoLockPixels image_lock(image);
 
   printer_->PrintImageHeader(actual_pixel_hash, expected_pixel_hash_);
 
   // Only encode and dump the png if the hashes don't match. Encoding the
   // image is really expensive.
   if (actual_pixel_hash != expected_pixel_hash_) {
     std::vector<unsigned char> png;
 
     bool discard_transparency = true;
@@ skipping 10 matching lines @@
         static_cast<int>(image.rowBytes()),
         discard_transparency,
         comments,
         &png);
     if (success)
       printer_->PrintImageBlock(png);
   }
   printer_->PrintImageFooter();
 }
 
-void WebKitTestController::OnAudioDump(const std::vector<unsigned char>& dump) {
+void BlinkTestController::OnAudioDump(const std::vector<unsigned char>& dump) {
   printer_->PrintAudioHeader();
   printer_->PrintAudioBlock(dump);
   printer_->PrintAudioFooter();
 }
 
-void WebKitTestController::OnTextDump(const std::string& dump) {
+void BlinkTestController::OnTextDump(const std::string& dump) {
   printer_->PrintTextHeader();
   printer_->PrintTextBlock(dump);
   printer_->PrintTextFooter();
 }
 
-void WebKitTestController::OnPrintMessage(const std::string& message) {
+void BlinkTestController::OnPrintMessage(const std::string& message) {
   printer_->AddMessageRaw(message);
 }
 
-void WebKitTestController::OnOverridePreferences(const WebPreferences& prefs) {
+void BlinkTestController::OnOverridePreferences(const WebPreferences& prefs) {
   should_override_prefs_ = true;
   prefs_ = prefs;
 }
 
-void WebKitTestController::OnClearDevToolsLocalStorage() {
+void BlinkTestController::OnClearDevToolsLocalStorage() {
   ShellBrowserContext* browser_context =
       ShellContentBrowserClient::Get()->browser_context();
   StoragePartition* storage_partition =
       BrowserContext::GetStoragePartition(browser_context, NULL);
   storage_partition->GetDOMStorageContext()->DeleteLocalStorage(
       content::LayoutTestDevToolsFrontend::GetDevToolsPathAsURL("", "")
           .GetOrigin());
 }
 
-void WebKitTestController::OnShowDevTools(const std::string& settings,
-                                          const std::string& frontend_url) {
+void BlinkTestController::OnShowDevTools(const std::string& settings,
+                                         const std::string& frontend_url) {
   if (!devtools_frontend_) {
     devtools_frontend_ = LayoutTestDevToolsFrontend::Show(
         main_window_->web_contents(), settings, frontend_url);
   } else {
     devtools_frontend_->ReuseFrontend(settings, frontend_url);
   }
   devtools_frontend_->Activate();
   devtools_frontend_->Focus();
 }
 
-void WebKitTestController::OnCloseDevTools() {
+void BlinkTestController::OnCloseDevTools() {
   if (devtools_frontend_)
     devtools_frontend_->DisconnectFromTarget();
 }
 
-void WebKitTestController::OnGoToOffset(int offset) {
+void BlinkTestController::OnGoToOffset(int offset) {
   main_window_->GoBackOrForward(offset);
 }
 
-void WebKitTestController::OnReload() {
+void BlinkTestController::OnReload() {
   main_window_->Reload();
 }
 
-void WebKitTestController::OnLoadURLForFrame(const GURL& url,
-                                             const std::string& frame_name) {
+void BlinkTestController::OnLoadURLForFrame(const GURL& url,
+                                            const std::string& frame_name) {
   main_window_->LoadURLForFrame(url, frame_name);
 }
 
-void WebKitTestController::OnCaptureSessionHistory() {
+void BlinkTestController::OnCaptureSessionHistory() {
   std::vector<int> routing_ids;
   std::vector<std::vector<PageState> > session_histories;
   std::vector<unsigned> current_entry_indexes;
 
   RenderViewHost* render_view_host =
       main_window_->web_contents()->GetRenderViewHost();
 
   for (std::vector<Shell*>::iterator window = Shell::windows().begin();
        window != Shell::windows().end();
        ++window) {
@@ skipping 21 matching lines @@
     }
     session_histories.push_back(history);
   }
 
   Send(new ShellViewMsg_SessionHistory(render_view_host->GetRoutingID(),
                                        routing_ids,
                                        session_histories,
                                        current_entry_indexes));
 }
 
-void WebKitTestController::OnCloseRemainingWindows() {
+void BlinkTestController::OnCloseRemainingWindows() {
   DevToolsAgentHost::DetachAllClients();
   std::vector<Shell*> open_windows(Shell::windows());
   Shell* devtools_shell = devtools_frontend_ ?
       devtools_frontend_->frontend_shell() : NULL;
   for (size_t i = 0; i < open_windows.size(); ++i) {
     if (open_windows[i] != main_window_ && open_windows[i] != devtools_shell)
       open_windows[i]->Close();
   }
   base::MessageLoop::current()->RunUntilIdle();
 }
 
-void WebKitTestController::OnResetDone() {
+void BlinkTestController::OnResetDone() {
   if (is_leak_detection_enabled_) {
     if (main_window_ && main_window_->web_contents()) {
       RenderViewHost* render_view_host =
           main_window_->web_contents()->GetRenderViewHost();
       render_view_host->Send(
           new ShellViewMsg_TryLeakDetection(render_view_host->GetRoutingID()));
     }
     return;
   }
 
   base::MessageLoop::current()->PostTask(FROM_HERE,
                                          base::MessageLoop::QuitClosure());
 }
 
-void WebKitTestController::OnLeakDetectionDone(
+void BlinkTestController::OnLeakDetectionDone(
     const LeakDetectionResult& result) {
   if (!result.leaked) {
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::MessageLoop::QuitClosure());
     return;
   }
 
   printer_->AddErrorMessage(
       base::StringPrintf("#LEAK - renderer pid %d (%s)", current_pid_,
                          result.detail.c_str()));
   CHECK(!crash_when_leak_found_);
 
   DiscardMainWindow();
 }
 
 }  // namespace content