1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "base/command_line.h" 6 #include "base/file_util.h" 7 #include "base/files/file.h" 8 #include "base/files/file_enumerator.h" 9 #include "base/hash.h" 10 #include "base/path_service.h" 11 #include "base/strings/string_number_conversions.h" 12 #include "base/strings/string_util.h" 13 #include "base/strings/utf_string_conversions.h" 14 #include "chrome/browser/chrome_notification_types.h" 15 #include "chrome/browser/ui/browser.h" 16 #include "chrome/browser/ui/browser_window.h" 17 #include "chrome/browser/ui/tabs/tab_strip_model.h" 18 #include "chrome/common/chrome_paths.h" 19 #include "chrome/test/base/in_process_browser_test.h" 20 #include "chrome/test/base/ui_test_utils.h" 21 #include "content/public/browser/navigation_controller.h" 22 #include "content/public/browser/notification_observer.h" 23 #include "content/public/browser/render_view_host.h" 24 #include "content/public/browser/web_contents.h" 25 #include "content/public/common/content_switches.h" 26 #include "content/public/test/browser_test_utils.h" 27 #include "net/test/embedded_test_server/embedded_test_server.h" 28 #include "third_party/skia/include/core/SkBitmap.h" 29 #include "ui/base/clipboard/clipboard.h" 30 #include "ui/gfx/codec/png_codec.h" 31 #include "ui/gfx/screen.h" 32 33 using content::NavigationController; 34 using content::WebContents; 35 36 // Note: All tests in here require the internal PDF plugin, so they're disabled 37 // in non-official builds. We still compile them though, to prevent bitrot. 38 39 namespace { 40 41 // Include things like browser frame and scrollbar and make sure we're bigger 42 // than the test pdf document. 43 static const int kBrowserWidth = 1000; 44 static const int kBrowserHeight = 600; 45 46 class PDFBrowserTest : public InProcessBrowserTest, 47 public testing::WithParamInterface<int>, 48 public content::NotificationObserver { 49 public: 50 PDFBrowserTest() 51 : snapshot_different_(true), 52 next_dummy_search_value_(0), 53 load_stop_notification_count_(0) { 54 base::FilePath src_dir; 55 EXPECT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &src_dir)); 56 pdf_test_server_.ServeFilesFromDirectory(src_dir.AppendASCII( 57 "chrome/test/data/pdf_private")); 58 } 59 60 protected: 61 // Use our own TestServer so that we can serve files from the pdf directory. 62 net::test_server::EmbeddedTestServer* pdf_test_server() { 63 return &pdf_test_server_; 64 } 65 66 int load_stop_notification_count() const { 67 return load_stop_notification_count_; 68 } 69 70 void Load() { 71 // Make sure to set the window size before rendering, as otherwise rendering 72 // to a smaller window and then expanding leads to slight anti-aliasing 73 // differences of the text and the pixel comparison fails. 74 gfx::Rect bounds(gfx::Rect(0, 0, kBrowserWidth, kBrowserHeight)); 75 gfx::Rect screen_bounds = 76 gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().bounds(); 77 ASSERT_GT(screen_bounds.width(), kBrowserWidth); 78 ASSERT_GT(screen_bounds.height(), kBrowserHeight); 79 browser()->window()->SetBounds(bounds); 80 81 GURL url(ui_test_utils::GetTestUrl( 82 base::FilePath(FILE_PATH_LITERAL("pdf_private")), 83 base::FilePath(FILE_PATH_LITERAL("pdf_browsertest.pdf")))); 84 ui_test_utils::NavigateToURL(browser(), url); 85 } 86 87 bool VerifySnapshot(const std::string& expected_filename) { 88 snapshot_different_ = true; 89 expected_filename_ = expected_filename; 90 WebContents* web_contents = 91 browser()->tab_strip_model()->GetActiveWebContents(); 92 DCHECK(web_contents); 93 94 content::RenderWidgetHost* rwh = web_contents->GetRenderViewHost(); 95 rwh->CopyFromBackingStore( 96 gfx::Rect(), 97 gfx::Size(), 98 base::Bind(&PDFBrowserTest::CopyFromBackingStoreCallback, this), 99 SkBitmap::kARGB_8888_Config); 100 101 content::RunMessageLoop(); 102 103 if (snapshot_different_) { 104 LOG(INFO) << "Rendering didn't match, see result " << 105 snapshot_filename_.value(); 106 } 107 return !snapshot_different_; 108 } 109 110 void WaitForResponse() { 111 // Even if the plugin has loaded the data or scrolled, because of how 112 // pepper painting works, we might not have the data. One way to force this 113 // to be flushed is to do a find operation, since on this two-page test 114 // document, it'll wait for us to flush the renderer message loop twice and 115 // also the browser's once, at which point we're guaranteed to have updated 116 // the backingstore. Hacky, but it works. 117 // Note that we need to change the text each time, because if we don't the 118 // renderer code will think the second message is to go to next result, but 119 // there are none so the plugin will assert. 120 121 base::string16 query = base::UTF8ToUTF16( 122 std::string("xyzxyz" + base::IntToString(next_dummy_search_value_++))); 123 ASSERT_EQ(0, ui_test_utils::FindInPage( 124 browser()->tab_strip_model()->GetActiveWebContents(), 125 query, true, false, NULL, NULL)); 126 } 127 128 private: 129 void CopyFromBackingStoreCallback(bool success, const SkBitmap& bitmap) { 130 base::MessageLoopForUI::current()->Quit(); 131 ASSERT_EQ(success, true); 132 base::FilePath reference = ui_test_utils::GetTestFilePath( 133 base::FilePath(FILE_PATH_LITERAL("pdf_private")), 134 base::FilePath().AppendASCII(expected_filename_)); 135 base::File::Info info; 136 ASSERT_TRUE(base::GetFileInfo(reference, &info)); 137 int size = static_cast<size_t>(info.size); 138 scoped_ptr<char[]> data(new char[size]); 139 ASSERT_EQ(size, base::ReadFile(reference, data.get(), size)); 140 141 int w, h; 142 std::vector<unsigned char> decoded; 143 ASSERT_TRUE(gfx::PNGCodec::Decode( 144 reinterpret_cast<unsigned char*>(data.get()), size, 145 gfx::PNGCodec::FORMAT_BGRA, &decoded, &w, &h)); 146 int32* ref_pixels = reinterpret_cast<int32*>(&decoded[0]); 147 148 int32* pixels = static_cast<int32*>(bitmap.getPixels()); 149 150 // Get the background color, and use it to figure out the x-offsets in 151 // each image. The reason is that depending on the theme in the OS, the 152 // same browser width can lead to slightly different plugin sizes, so the 153 // pdf content will start at different x offsets. 154 // Also note that the images we saved are cut off before the scrollbar, as 155 // that'll change depending on the theme, and also cut off vertically so 156 // that the ui controls don't show up, as those fade-in and so the timing 157 // will affect their transparency. 158 int32 bg_color = ref_pixels[0]; 159 int ref_x_offset, snapshot_x_offset; 160 for (ref_x_offset = 0; ref_x_offset < w; ++ref_x_offset) { 161 if (ref_pixels[ref_x_offset] != bg_color) 162 break; 163 } 164 165 for (snapshot_x_offset = 0; snapshot_x_offset < bitmap.width(); 166 ++snapshot_x_offset) { 167 if (pixels[snapshot_x_offset] != bg_color) 168 break; 169 } 170 171 int x_max = std::min( 172 w - ref_x_offset, bitmap.width() - snapshot_x_offset); 173 int y_max = std::min(h, bitmap.height()); 174 int stride = bitmap.rowBytes(); 175 snapshot_different_ = false; 176 for (int y = 0; y < y_max && !snapshot_different_; ++y) { 177 for (int x = 0; x < x_max && !snapshot_different_; ++x) { 178 if (pixels[y * stride / sizeof(int32) + x + snapshot_x_offset] != 179 ref_pixels[y * w + x + ref_x_offset]) 180 snapshot_different_ = true; 181 } 182 } 183 184 if (snapshot_different_) { 185 std::vector<unsigned char> png_data; 186 gfx::PNGCodec::EncodeBGRASkBitmap(bitmap, false, &png_data); 187 if (base::CreateTemporaryFile(&snapshot_filename_)) { 188 base::WriteFile(snapshot_filename_, 189 reinterpret_cast<char*>(&png_data[0]), png_data.size()); 190 } 191 } 192 } 193 194 // content::NotificationObserver 195 virtual void Observe(int type, 196 const content::NotificationSource& source, 197 const content::NotificationDetails& details) OVERRIDE { 198 if (type == content::NOTIFICATION_LOAD_STOP) { 199 load_stop_notification_count_++; 200 } 201 } 202 203 // InProcessBrowserTest 204 virtual void SetUpCommandLine(base::CommandLine* command_line) OVERRIDE { 205 #if defined(OS_LINUX) 206 // Calling RenderWidgetHost::CopyFromBackingStore() with the GPU enabled 207 // fails on Linux. 208 command_line->AppendSwitch(switches::kDisableGpu); 209 #endif 210 } 211 212 // True if the snapshot differed from the expected value. 213 bool snapshot_different_; 214 // Internal variable used to synchronize to the renderer. 215 int next_dummy_search_value_; 216 // The filename of the bitmap to compare the snapshot to. 217 std::string expected_filename_; 218 // If the snapshot is different, holds the location where it's saved. 219 base::FilePath snapshot_filename_; 220 // How many times we've seen chrome::LOAD_STOP. 221 int load_stop_notification_count_; 222 223 net::test_server::EmbeddedTestServer pdf_test_server_; 224 }; 225 226 227 // Tests basic PDF rendering. This can be broken depending on bad merges with 228 // the vendor, so it's important that we have basic sanity checking. 229 #if defined(GOOGLE_CHROME_BUILD) && defined(OS_LINUX) 230 #define MAYBE_Basic Basic 231 #else 232 #define MAYBE_Basic DISABLED_Basic 233 #endif 234 IN_PROC_BROWSER_TEST_F(PDFBrowserTest, MAYBE_Basic) { 235 ASSERT_NO_FATAL_FAILURE(Load()); 236 ASSERT_NO_FATAL_FAILURE(WaitForResponse()); 237 // OS X uses CoreText, and FreeType renders slightly different on Linux and 238 // Win. 239 #if defined(OS_MACOSX) 240 // The bots render differently than locally, see http://crbug.com/142531. 241 ASSERT_TRUE(VerifySnapshot("pdf_browsertest_mac.png") || 242 VerifySnapshot("pdf_browsertest_mac2.png")); 243 #elif defined(OS_LINUX) 244 ASSERT_TRUE(VerifySnapshot("pdf_browsertest_linux.png")); 245 #else 246 ASSERT_TRUE(VerifySnapshot("pdf_browsertest.png")); 247 #endif 248 } 249 250 #if defined(GOOGLE_CHROME_BUILD) && (defined(OS_WIN) || defined(OS_LINUX)) 251 #define MAYBE_Scroll Scroll 252 #else 253 // TODO(thestig): http://crbug.com/79837, http://crbug.com/332778 254 #define MAYBE_Scroll DISABLED_Scroll 255 #endif 256 // Tests that scrolling works. 257 IN_PROC_BROWSER_TEST_F(PDFBrowserTest, MAYBE_Scroll) { 258 ASSERT_NO_FATAL_FAILURE(Load()); 259 260 // We use wheel mouse event since that's the only one we can easily push to 261 // the renderer. There's no way to push a cross-platform keyboard event at 262 // the moment. 263 blink::WebMouseWheelEvent wheel_event; 264 wheel_event.type = blink::WebInputEvent::MouseWheel; 265 wheel_event.deltaY = -200; 266 wheel_event.wheelTicksY = -2; 267 WebContents* web_contents = 268 browser()->tab_strip_model()->GetActiveWebContents(); 269 web_contents->GetRenderViewHost()->ForwardWheelEvent(wheel_event); 270 ASSERT_NO_FATAL_FAILURE(WaitForResponse()); 271 272 int y_offset = 0; 273 ASSERT_TRUE(content::ExecuteScriptAndExtractInt( 274 browser()->tab_strip_model()->GetActiveWebContents(), 275 "window.domAutomationController.send(plugin.pageYOffset())", 276 &y_offset)); 277 ASSERT_GT(y_offset, 0); 278 } 279 280 #if defined(GOOGLE_CHROME_BUILD) && (defined(OS_WIN) || defined(OS_LINUX)) 281 #define MAYBE_FindAndCopy FindAndCopy 282 #else 283 // TODO(thestig): http://crbug.com/79837, http://crbug.com/329912 284 #define MAYBE_FindAndCopy DISABLED_FindAndCopy 285 #endif 286 // flaky, disabling on branch 287 IN_PROC_BROWSER_TEST_F(PDFBrowserTest, DISABLED_FindAndCopy) { 288 ASSERT_NO_FATAL_FAILURE(Load()); 289 // Verifies that find in page works. 290 ASSERT_EQ(3, ui_test_utils::FindInPage( 291 browser()->tab_strip_model()->GetActiveWebContents(), 292 base::UTF8ToUTF16("adipiscing"), 293 true, false, NULL, NULL)); 294 295 // Verify that copying selected text works. 296 ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread(); 297 // Reset the clipboard first. 298 clipboard->Clear(ui::CLIPBOARD_TYPE_COPY_PASTE); 299 300 browser()->tab_strip_model()->GetActiveWebContents()->Copy(); 301 ASSERT_NO_FATAL_FAILURE(WaitForResponse()); 302 303 std::string text; 304 clipboard->ReadAsciiText(ui::CLIPBOARD_TYPE_COPY_PASTE, &text); 305 ASSERT_EQ("adipiscing", text); 306 } 307 308 const int kLoadingNumberOfParts = 10; 309 310 // Tests that loading async pdfs works correctly (i.e. document fully loads). 311 // This also loads all documents that used to crash, to ensure we don't have 312 // regressions. 313 // If it flakes, reopen http://crbug.com/74548. 314 #if defined(GOOGLE_CHROME_BUILD) 315 #define MAYBE_Loading Loading 316 #else 317 #define MAYBE_Loading DISABLED_Loading 318 #endif 319 IN_PROC_BROWSER_TEST_P(PDFBrowserTest, MAYBE_Loading) { 320 ASSERT_TRUE(pdf_test_server()->InitializeAndWaitUntilReady()); 321 322 NavigationController* controller = 323 &(browser()->tab_strip_model()->GetActiveWebContents()->GetController()); 324 content::NotificationRegistrar registrar; 325 registrar.Add(this, 326 content::NOTIFICATION_LOAD_STOP, 327 content::Source<NavigationController>(controller)); 328 std::string base_url = std::string("/"); 329 330 base::FileEnumerator file_enumerator( 331 ui_test_utils::GetTestFilePath( 332 base::FilePath(FILE_PATH_LITERAL("pdf_private")), base::FilePath()), 333 false, 334 base::FileEnumerator::FILES, 335 FILE_PATH_LITERAL("*.pdf")); 336 for (base::FilePath file_path = file_enumerator.Next(); 337 !file_path.empty(); 338 file_path = file_enumerator.Next()) { 339 std::string filename = file_path.BaseName().MaybeAsASCII(); 340 ASSERT_FALSE(filename.empty()); 341 342 #if defined(OS_POSIX) 343 if (filename == "sample.pdf") 344 continue; // Crashes on Mac and Linux. http://crbug.com/63549 345 #endif 346 347 // Split the test into smaller sub-tests. Each one only loads 348 // every k-th file. 349 if (static_cast<int>(base::Hash(filename) % kLoadingNumberOfParts) != 350 GetParam()) { 351 continue; 352 } 353 354 LOG(WARNING) << "PDFBrowserTest.Loading: " << filename; 355 356 GURL url = pdf_test_server()->GetURL(base_url + filename); 357 ui_test_utils::NavigateToURL(browser(), url); 358 359 while (true) { 360 int last_count = load_stop_notification_count(); 361 // We might get extraneous chrome::LOAD_STOP notifications when 362 // doing async loading. This happens when the first loader is cancelled 363 // and before creating a byte-range request loader. 364 bool complete = false; 365 ASSERT_TRUE(content::ExecuteScriptAndExtractBool( 366 browser()->tab_strip_model()->GetActiveWebContents(), 367 "window.domAutomationController.send(plugin.documentLoadComplete())", 368 &complete)); 369 if (complete) 370 break; 371 372 // Check if the LOAD_STOP notification could have come while we run a 373 // nested message loop for the JS call. 374 if (last_count != load_stop_notification_count()) 375 continue; 376 content::WaitForLoadStop( 377 browser()->tab_strip_model()->GetActiveWebContents()); 378 } 379 } 380 } 381 382 INSTANTIATE_TEST_CASE_P(PDFTestFiles, 383 PDFBrowserTest, 384 testing::Range(0, kLoadingNumberOfParts)); 385 386 #if defined(GOOGLE_CHROME_BUILD) && (defined(OS_WIN) || defined(OS_LINUX)) 387 #define MAYBE_Action Action 388 #else 389 // http://crbug.com/315160 390 #define MAYBE_Action DISABLED_Action 391 #endif 392 IN_PROC_BROWSER_TEST_F(PDFBrowserTest, MAYBE_Action) { 393 ASSERT_NO_FATAL_FAILURE(Load()); 394 395 ASSERT_TRUE(content::ExecuteScript( 396 browser()->tab_strip_model()->GetActiveWebContents(), 397 "document.getElementsByName('plugin')[0].fitToHeight();")); 398 399 std::string zoom1, zoom2; 400 ASSERT_TRUE(content::ExecuteScriptAndExtractString( 401 browser()->tab_strip_model()->GetActiveWebContents(), 402 "window.domAutomationController.send(" 403 " document.getElementsByName('plugin')[0].getZoomLevel().toString())", 404 &zoom1)); 405 406 ASSERT_TRUE(content::ExecuteScript( 407 browser()->tab_strip_model()->GetActiveWebContents(), 408 "document.getElementsByName('plugin')[0].fitToWidth();")); 409 410 ASSERT_TRUE(content::ExecuteScriptAndExtractString( 411 browser()->tab_strip_model()->GetActiveWebContents(), 412 "window.domAutomationController.send(" 413 " document.getElementsByName('plugin')[0].getZoomLevel().toString())", 414 &zoom2)); 415 ASSERT_NE(zoom1, zoom2); 416 } 417 418 #if defined(GOOGLE_CHROME_BUILD) && defined(OS_LINUX) 419 #define MAYBE_OnLoadAndReload OnLoadAndReload 420 #else 421 // Flaky as per http://crbug.com/74549. 422 #define MAYBE_OnLoadAndReload DISABLED_OnLoadAndReload 423 #endif 424 IN_PROC_BROWSER_TEST_F(PDFBrowserTest, MAYBE_OnLoadAndReload) { 425 ASSERT_TRUE(pdf_test_server()->InitializeAndWaitUntilReady()); 426 427 GURL url = pdf_test_server()->GetURL("/onload_reload.html"); 428 ui_test_utils::NavigateToURL(browser(), url); 429 WebContents* contents = browser()->tab_strip_model()->GetActiveWebContents(); 430 431 content::WindowedNotificationObserver observer( 432 content::NOTIFICATION_LOAD_STOP, 433 content::Source<NavigationController>( 434 &contents->GetController())); 435 ASSERT_TRUE(content::ExecuteScript( 436 browser()->tab_strip_model()->GetActiveWebContents(), 437 "reloadPDF();")); 438 observer.Wait(); 439 440 ASSERT_EQ("success", contents->GetURL().query()); 441 } 442 443 } // namespace 444
