Remove HttpTransactionWinHttp and the --winhttp command-line...

webkit/tools/test_shell/test_shell_win.cc

 // Copyright (c) 2006-2008 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 "webkit/tools/test_shell/test_shell.h"
+
 #include <windows.h>
 #include <atlbase.h>
 #include <commdlg.h>
 #include <objbase.h>
 #include <shlwapi.h>
-#include <wininet.h>
-
-#include "webkit/tools/test_shell/test_shell.h"
+#include <wininet.h>  // For INTERNET_MAX_URL_LENGTH
 
 #include "base/command_line.h"
 #include "base/memory_debug.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/resource_util.h"
 #include "base/stack_container.h"
 #include "base/string_util.h"
 #include "base/trace_event.h"
 #include "base/win_util.h"
@@ skipping 113 matching lines @@
   DWORD num_fonts = 1;
   void* font_ptr;
   size_t font_size;
   if (base::GetDataResourceFromModule(::GetModuleHandle(NULL), IDR_AHEM_FONT,
                                       &font_ptr, &font_size)) {
     HANDLE rc = AddFontMemResourceEx(font_ptr, font_size, 0, &num_fonts);
     DCHECK(rc != 0);
   }
 
   CommandLine parsed_command_line;
-  // Make the selection of network stacks early on before any consumers try to
-  // issue HTTP requests.
-  if (parsed_command_line.HasSwitch(test_shell::kUseWinHttp))
-    net::HttpNetworkLayer::UseWinHttp(true);
-
   if (parsed_command_line.HasSwitch(test_shell::kCrashDumps)) {
     std::wstring dir(
         parsed_command_line.GetSwitchValue(test_shell::kCrashDumps));
     new google_breakpad::ExceptionHandler(dir, 0, &MinidumpCallback, 0, true);
   }
 }
 
 bool TestShell::CreateNewWindow(const std::wstring& startingURL,
                                 TestShell** result) {
   TestShell* shell = new TestShell();
@@ skipping 55 matching lines @@
   if (TestShell::windowList()->empty()) {
     LOG(ERROR) << "No windows open.";
     return false;
   }
 
   HWND hwnd = *(TestShell::windowList()->begin());
   TestShell* shell =
       static_cast<TestShell*>(win_util::GetWindowUserData(hwnd));
   shell->ResetTestController();
 
-  // ResetTestController may have closed the window we were holding on to. 
+  // ResetTestController may have closed the window we were holding on to.
   // Grab the first window again.
   hwnd = *(TestShell::windowList()->begin());
   shell = static_cast<TestShell*>(win_util::GetWindowUserData(hwnd));
   DCHECK(shell);
 
   // Clear focus between tests.
   shell->m_focusedWidgetHost = NULL;
 
   // Make sure the previous load is stopped.
   shell->webView()->StopLoading();
@@ skipping 28 matching lines @@
   if (webFrame) {
     bool should_dump_as_text =
         shell->layout_test_controller_->ShouldDumpAsText();
     bool dumped_anything = false;
     if (params.dump_tree) {
       dumped_anything = true;
       // Text output: the test page can request different types of output
       // which we handle here.
       if (!should_dump_as_text) {
         // Plain text pages should be dumped as text
-        std::wstring mime_type = webFrame->GetDataSource()->GetResponseMimeType();
+        std::wstring mime_type =
+            webFrame->GetDataSource()->GetResponseMimeType();
         should_dump_as_text = (mime_type == L"text/plain");
       }
       if (should_dump_as_text) {
         bool recursive = shell->layout_test_controller_->
             ShouldDumpChildFramesAsText();
         std::string data_utf8 = WideToUTF8(
             webkit_glue::DumpFramesAsText(webFrame, recursive));
         fwrite(data_utf8.c_str(), 1, data_utf8.size(), stdout);
       } else {
         printf("%s", WideToUTF8(
             webkit_glue::DumpRenderer(webFrame)).c_str());
 
         bool recursive = shell->layout_test_controller_->
             ShouldDumpChildFrameScrollPositions();
         printf("%s", WideToUTF8(
             webkit_glue::DumpFrameScrollPosition(webFrame, recursive)).c_str());
       }
 
       if (shell->layout_test_controller_->ShouldDumpBackForwardList()) {
         std::wstring bfDump;
         DumpBackForwardList(&bfDump);
         printf("%s", WideToUTF8(bfDump).c_str());
       }
     }
-    
+
     if (params.dump_pixels && !should_dump_as_text) {
       // Image output: we write the image data to the file given on the
       // command line (for the dump pixels argument), and the MD5 sum to
       // stdout.
       dumped_anything = true;
       std::string md5sum = DumpImage(webFrame, params.pixel_file_name);
       printf("#MD5:%s\n", md5sum.c_str());
     }
     if (dumped_anything)
       printf("#EOF\n");
@@ skipping 24 matching lines @@
   }
   return new_url;
 }
 
 
 
 /////////////////////////////////////////////////////////////////////////////
 // TestShell implementation
 
 void TestShell::PlatformCleanUp() {
-  // When the window is destroyed, tell the Edit field to forget about us, 
-  // otherwise we will crash. 
+  // When the window is destroyed, tell the Edit field to forget about us,
+  // otherwise we will crash.
   win_util::SetWindowProc(m_editWnd, default_edit_wnd_proc_);
   win_util::SetWindowUserData(m_editWnd, NULL);
 }
 
 bool TestShell::Initialize(const std::wstring& startingURL) {
   // Perform application initialization:
   m_mainWnd = CreateWindow(g_windowClass, g_windowTitle,
                            WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
                            CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
                            NULL, NULL, instance_handle_, NULL);
   win_util::SetWindowUserData(m_mainWnd, this);
 
   HWND hwnd;
   int x = 0;
-  
+
   hwnd = CreateWindow(L"BUTTON", L"Back",
                       WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON ,
                       x, 0, BUTTON_WIDTH, URLBAR_HEIGHT,
                       m_mainWnd, (HMENU) IDC_NAV_BACK, instance_handle_, 0);
   x += BUTTON_WIDTH;
 
   hwnd = CreateWindow(L"BUTTON", L"Forward",
                       WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON ,
                       x, 0, BUTTON_WIDTH, URLBAR_HEIGHT,
                       m_mainWnd, (HMENU) IDC_NAV_FORWARD, instance_handle_, 0);
   x += BUTTON_WIDTH;
 
   hwnd = CreateWindow(L"BUTTON", L"Reload",
                       WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON ,
                       x, 0, BUTTON_WIDTH, URLBAR_HEIGHT,
                       m_mainWnd, (HMENU) IDC_NAV_RELOAD, instance_handle_, 0);
   x += BUTTON_WIDTH;
 
   hwnd = CreateWindow(L"BUTTON", L"Stop",
                       WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON ,
                       x, 0, BUTTON_WIDTH, URLBAR_HEIGHT,
                       m_mainWnd, (HMENU) IDC_NAV_STOP, instance_handle_, 0);
   x += BUTTON_WIDTH;
 
   // this control is positioned by ResizeSubViews
   m_editWnd = CreateWindow(L"EDIT", 0,
                            WS_CHILD | WS_VISIBLE | WS_BORDER | ES_LEFT |
-                           ES_AUTOVSCROLL | ES_AUTOHSCROLL, 
+                           ES_AUTOVSCROLL | ES_AUTOHSCROLL,
                            x, 0, 0, 0, m_mainWnd, 0, instance_handle_, 0);
 
   default_edit_wnd_proc_ =
       win_util::SetWindowProc(m_editWnd, TestShell::EditWndProc);
   win_util::SetWindowUserData(m_editWnd, this);
 
   // create webview
   m_webViewHost.reset(
       WebViewHost::Create(m_mainWnd, delegate_.get(), *TestShell::web_prefs_));
   webView()->SetUseEditorDelegate(true);
   delegate_->RegisterDragDrop();
-  
+
   // Load our initial content.
   if (!startingURL.empty())
     LoadURL(startingURL.c_str());
 
   ShowWindow(webViewWnd(), SW_SHOW);
 
   bool bIsSVGTest = startingURL.find(L"W3C-SVG-1.1") != std::wstring::npos;
 
   if (bIsSVGTest) {
     SizeToSVG();
@@ skipping 37 matching lines @@
   return 0;
 }
 
 void TestShell::WaitTestFinished() {
   DCHECK(!test_is_pending_) << "cannot be used recursively";
 
   test_is_pending_ = true;
 
   // Create a watchdog thread which just sets a timer and
   // kills the process if it times out.  This catches really
-  // bad hangs where the shell isn't coming back to the 
-  // message loop.  If the watchdog is what catches a 
+  // bad hangs where the shell isn't coming back to the
+  // message loop.  If the watchdog is what catches a
   // timeout, it can't do anything except terminate the test
   // shell, which is unfortunate.
   finished_event_ = CreateEvent(NULL, TRUE, FALSE, NULL);
   DCHECK(finished_event_ != NULL);
 
   HANDLE thread_handle = reinterpret_cast<HANDLE>(_beginthreadex(
                                  NULL,
                                  0,
                                  &WatchDogThread,
                                  this,
                                  0,
                                  0));
   DCHECK(thread_handle != NULL);
 
   // TestFinished() will post a quit message to break this loop when the page
   // finishes loading.
   while (test_is_pending_)
     MessageLoop::current()->Run();
 
   // Tell the watchdog that we are finished.
   SetEvent(finished_event_);
 
   // Wait to join the watchdog thread.  (up to 1s, then quit)
-  WaitForSingleObject(thread_handle, 1000);  
+  WaitForSingleObject(thread_handle, 1000);
 }
 
 void TestShell::InteractiveSetFocus(WebWidgetHost* host, bool enable) {
   if (!enable && ::GetFocus() == host->view_handle())
     ::SetFocus(NULL);
 }
 
 WebWidget* TestShell::CreatePopupWidget(WebView* webview) {
   DCHECK(!m_popupHost);
   m_popupHost = WebWidgetHost::Create(NULL, delegate_.get());
@@ skipping 147 matching lines @@
 
 LRESULT CALLBACK TestShell::EditWndProc(HWND hwnd, UINT message,
                                         WPARAM wParam, LPARAM lParam) {
   TestShell* shell =
       static_cast<TestShell*>(win_util::GetWindowUserData(hwnd));
 
   switch (message) {
     case WM_CHAR:
       if (wParam == VK_RETURN) {
         wchar_t strPtr[MAX_URL_LENGTH + 1];  // Leave room for adding a NULL;
-        *((LPWORD)strPtr) = MAX_URL_LENGTH; 
+        *((LPWORD)strPtr) = MAX_URL_LENGTH;
         LRESULT strLen = SendMessage(hwnd, EM_GETLINE, 0, (LPARAM)strPtr);
         if (strLen > 0) {
           strPtr[strLen] = 0;  // EM_GETLINE doesn't NULL terminate.
           shell->LoadURL(strPtr);
         }
 
         return 0;
       }
   }
 
@@ skipping 69 matching lines @@
 
 bool EnsureFontLoaded(HFONT font) {
   return true;
 }
 
 bool DownloadUrl(const std::string& url, HWND caller_window) {
   return false;
 }
 
 }  // namespace webkit_glue