Switch the PDF browser test to get its data from the pdf repo.

chrome/test/plugin/pdf_browsertest.cc

 // Copyright (c) 2010 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 "app/clipboard/clipboard.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/window_sizer.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/notification_observer.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/test/in_process_browser_test.h"
 #include "chrome/test/ui_test_utils.h"
 #include "gfx/codec/png_codec.h"
+#include "net/test/test_server.h"
 
 extern base::hash_map<std::string, int> g_test_timeout_overrides;
 
 namespace {
 
 // Include things like browser frame and scrollbar and make sure we're bigger
 // than the test pdf document.
 static const int kBrowserWidth = 1000;
 static const int kBrowserHeight = 600;
 static const int kLoadingTestTimeoutMs = 60000;
@@ skipping 11 matching lines @@
 IncreaseLoadingTimeout g_increase_loading_timeout;
 
 class PDFBrowserTest : public InProcessBrowserTest,
                        public NotificationObserver {
  public:
   PDFBrowserTest()
       : snapshot_different_(true),
         next_dummy_search_value_(0),
         load_stop_notification_count_(0) {
     EnableDOMAutomation();
+
+    pdf_test_server_.reset(new net::TestServer(
+      net::TestServer::TYPE_HTTP,
+      FilePath(FILE_PATH_LITERAL("pdf/test"))));

[chase, 2010/11/20 02:41:31]

Can GetPDFTestDir() be reused here too or does the TestServer start from a
different directory than the current process's working directory?

   }
 
  protected:
+  net::TestServer* pdf_test_server() { return pdf_test_server_.get(); }
+
   int load_stop_notification_count() const {
     return load_stop_notification_count_;
   }
 
-  virtual void SetUp() {
-    FilePath pdf_path;
-    PathService::Get(chrome::FILE_PDF_PLUGIN, &pdf_path);
-    InProcessBrowserTest::SetUp();
-  }
-
   FilePath GetPDFTestDir() {
-    return FilePath(FilePath::kCurrentDirectory).AppendASCII("plugin").
-        AppendASCII("pdf");
+    return FilePath(FilePath::kCurrentDirectory).AppendASCII("..").
+        AppendASCII("..").AppendASCII("..").AppendASCII("pdf").
+        AppendASCII("test");
   }
 
   void Load() {
     GURL url(ui_test_utils::GetTestUrl(
         GetPDFTestDir(),
         FilePath(FILE_PATH_LITERAL("pdf_browsertest.pdf"))));
     ui_test_utils::NavigateToURL(browser(), url);
     gfx::Rect bounds(gfx::Rect(0, 0, kBrowserWidth, kBrowserHeight));
 
     scoped_ptr<WindowSizer::MonitorInfoProvider> monitor_info(
@@ skipping 116 matching lines @@
   // True if the snapshot differed from the expected value.
   bool snapshot_different_;
   // Internal variable used to synchronize to the renderer.
   int next_dummy_search_value_;
   // The filename of the bitmap to compare the snapshot to.
   std::string expected_filename_;
   // If the snapshot is different, holds the location where it's saved.
   FilePath snapshot_filename_;
   // How many times we've seen NotificationType::LOAD_STOP.
   int load_stop_notification_count_;
+
+  scoped_ptr<net::TestServer> pdf_test_server_;

[chase, 2010/11/20 02:41:31]

Would be good to have a comment here describing why a different test server is
needed compared to the provided test_server.

 };
 
 #if defined(OS_MACOSX)
 // See http://crbug.com/63223
 #define MAYBE_Basic FLAKY_Basic
 #else
 #define MAYBE_Basic Basic
 #endif
 
 // Tests basic PDF rendering.  This can be broken depending on bad merges with
@@ skipping 57 matching lines @@
 
   std::string text;
   clipboard.ReadAsciiText(Clipboard::BUFFER_STANDARD, &text);
   ASSERT_EQ("adipiscing", text);
 }
 
 // Tests that loading async pdfs works correctly (i.e. document fully loads).
 // This also loads all documents that used to crash, to ensure we don't have
 // regressions.
 IN_PROC_BROWSER_TEST_F(PDFBrowserTest, Loading) {
-  ASSERT_TRUE(test_server()->Start());
+  ASSERT_TRUE(pdf_test_server()->Start());
 
   NavigationController* controller =
       &(browser()->GetSelectedTabContents()->controller());
   NotificationRegistrar registrar;
   registrar.Add(this,
                 NotificationType::LOAD_STOP,
                 Source<NavigationController>(controller));
-  std::string base_url = std::string("files/plugin/pdf/");
+  std::string base_url = std::string("files/");
 
   file_util::FileEnumerator file_enumerator(
       ui_test_utils::GetTestFilePath(GetPDFTestDir(), FilePath()),
       false,
       file_util::FileEnumerator::FILES,
       FILE_PATH_LITERAL("*.pdf"));
   for (FilePath file_path = file_enumerator.Next();
        !file_path.empty();
        file_path = file_enumerator.Next()) {
     std::string filename = WideToASCII(file_path.BaseName().ToWStringHack());
 
 #if defined(OS_MACOSX) || defined(OS_LINUX)
     if (filename == "sample.pdf")
       continue;  // Crashes on Mac and Linux.  http://crbug.com/63549
 #endif
 
     LOG(WARNING) << "PDFBrowserTest.Loading: " << filename;
 
-    GURL url = test_server()->GetURL(base_url + filename);
+    GURL url = pdf_test_server()->GetURL(base_url + filename);
     ui_test_utils::NavigateToURL(browser(), url);
 
     while (true) {
       int last_count = load_stop_notification_count();
       // We might get extraneous NotificationType::LOAD_STOP notifications when
       // doing async loading.  This happens when the first loader is cancelled
       // and before creating a byte-range request loader.
       bool complete = false;
       ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
           browser()->GetSelectedTabContents()->render_view_host(),
           std::wstring(),
           L"window.domAutomationController.send(plugin.documentLoadComplete())",
           &complete));
       if (complete)
         break;
 
       // Check if the LOAD_STOP notification could have come while we run a
       // nested message loop for the JS call.
       if (last_count != load_stop_notification_count())
         continue;
       ui_test_utils::WaitForLoadStop(controller);
     }
   }
 }
 
 }  // namespace