chrome/browser/browser_encoding_browsertest.cc

   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/bind.h"
   6 #include "base/files/file_util.h"
   7 #include "base/files/scoped_temp_dir.h"
   8 #include "base/prefs/pref_service.h"
   9 #include "chrome/browser/character_encoding.h"
  10 #include "chrome/browser/net/url_request_mock_util.h"
  11 #include "chrome/browser/profiles/profile.h"
  12 #include "chrome/browser/ui/browser.h"
  13 #include "chrome/browser/ui/browser_commands.h"
  14 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  15 #include "chrome/common/pref_names.h"
  16 #include "chrome/test/base/in_process_browser_test.h"
  17 #include "chrome/test/base/ui_test_utils.h"
  18 #include "content/public/browser/browser_thread.h"
  19 #include "content/public/browser/download_manager.h"
  20 #include "content/public/browser/navigation_controller.h"
  21 #include "content/public/browser/notification_service.h"
  22 #include "content/public/browser/notification_source.h"
  23 #include "content/public/browser/notification_types.h"
  24 #include "content/public/browser/web_contents.h"
  25 #include "content/public/test/test_navigation_observer.h"
  26 #include "net/test/url_request/url_request_mock_http_job.h"
  27
  28 namespace {
  29
  30 struct EncodingTestData {
  31   const char* file_name;
  32   const char* encoding_name;
  33 };
  34
  35 const EncodingTestData kEncodingTestDatas[] = {
  36   { "Big5.html", "Big5" },
  37   { "EUC-JP.html", "EUC-JP" },
  38   { "gb18030.html", "gb18030" },
  39   { "iso-8859-1.html", "windows-1252" },
  40   { "ISO-8859-2.html", "ISO-8859-2" },
  41   { "ISO-8859-4.html", "ISO-8859-4" },
  42   { "ISO-8859-5.html", "ISO-8859-5" },
  43   { "ISO-8859-6.html", "ISO-8859-6" },
  44   { "ISO-8859-7.html", "ISO-8859-7" },
  45   { "ISO-8859-8.html", "ISO-8859-8" },
  46   { "ISO-8859-13.html", "ISO-8859-13" },
  47   { "ISO-8859-15.html", "ISO-8859-15" },
  48   { "KOI8-R.html", "KOI8-R" },
  49   { "KOI8-U.html", "KOI8-U" },
  50   { "macintosh.html", "macintosh" },
  51   { "Shift-JIS.html", "Shift_JIS" },
  52   { "US-ASCII.html", "windows-1252" },  // http://crbug.com/15801
  53   { "UTF-8.html", "UTF-8" },
  54   { "UTF-16LE.html", "UTF-16LE" },
  55   { "windows-874.html", "windows-874" },
  56   { "EUC-KR.html", "EUC-KR" },
  57   { "windows-1250.html", "windows-1250" },
  58   { "windows-1251.html", "windows-1251" },
  59   { "windows-1252.html", "windows-1252" },
  60   { "windows-1253.html", "windows-1253" },
  61   { "windows-1254.html", "windows-1254" },
  62   { "windows-1255.html", "windows-1255" },
  63   { "windows-1256.html", "windows-1256" },
  64   { "windows-1257.html", "windows-1257" },
  65   { "windows-1258.html", "windows-1258" }
  66 };
  67
  68 class SavePackageFinishedObserver : public content::DownloadManager::Observer {
  69  public:
  70   SavePackageFinishedObserver(content::DownloadManager* manager,
  71                               const base::Closure& callback)
  72       : download_manager_(manager),
  73         callback_(callback) {
  74     download_manager_->AddObserver(this);
  75   }
  76
  77   ~SavePackageFinishedObserver() override {
  78     if (download_manager_)
  79       download_manager_->RemoveObserver(this);
  80   }
  81
  82   // DownloadManager::Observer:
  83   void OnSavePackageSuccessfullyFinished(content::DownloadManager* manager,
  84                                          content::DownloadItem* item) override {
  85     callback_.Run();
  86   }
  87   void ManagerGoingDown(content::DownloadManager* manager) override {
  88     download_manager_->RemoveObserver(this);
  89     download_manager_ = NULL;
  90   }
  91
  92  private:
  93   content::DownloadManager* download_manager_;
  94   base::Closure callback_;
  95
  96   DISALLOW_COPY_AND_ASSIGN(SavePackageFinishedObserver);
  97 };
  98
  99 }  // namespace
 100
 101 using content::BrowserThread;
 102
 103 static const base::FilePath::CharType* kTestDir =
 104     FILE_PATH_LITERAL("encoding_tests");
 105
 106 class BrowserEncodingTest
 107     : public InProcessBrowserTest,
 108       public testing::WithParamInterface<EncodingTestData> {
 109  protected:
 110   BrowserEncodingTest() {}
 111
 112   // Saves the current page and verifies that the output matches the expected
 113   // result.
 114   void SaveAndCompare(const char* filename_to_write,
 115                       const base::FilePath& expected) {
 116     // Dump the page, the content of dump page should be identical to the
 117     // expected result file.
 118     base::FilePath full_file_name = save_dir_.AppendASCII(filename_to_write);
 119     // We save the page as way of complete HTML file, which requires a directory
 120     // name to save sub resources in it. Although this test file does not have
 121     // sub resources, but the directory name is still required.
 122     scoped_refptr<content::MessageLoopRunner> loop_runner(
 123         new content::MessageLoopRunner);
 124     SavePackageFinishedObserver observer(
 125         content::BrowserContext::GetDownloadManager(browser()->profile()),
 126         loop_runner->QuitClosure());
 127     browser()->tab_strip_model()->GetActiveWebContents()->SavePage(
 128         full_file_name, temp_sub_resource_dir_,
 129         content::SAVE_PAGE_TYPE_AS_COMPLETE_HTML);
 130     loop_runner->Run();
 131
 132     base::FilePath expected_file_name = ui_test_utils::GetTestFilePath(
 133         base::FilePath(kTestDir), expected);
 134
 135     EXPECT_TRUE(base::ContentsEqual(full_file_name, expected_file_name)) <<
 136         "generated_file = " << full_file_name.AsUTF8Unsafe() <<
 137         ", expected_file = " << expected_file_name.AsUTF8Unsafe();
 138   }
 139
 140   void SetUpOnMainThread() override {
 141     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 142     save_dir_ = temp_dir_.path();
 143     temp_sub_resource_dir_ = save_dir_.AppendASCII("sub_resource_files");
 144
 145     BrowserThread::PostTask(
 146         BrowserThread::IO, FROM_HERE,
 147         base::Bind(&chrome_browser_net::SetUrlRequestMocksEnabled, true));
 148   }
 149
 150   base::ScopedTempDir temp_dir_;
 151   base::FilePath save_dir_;
 152   base::FilePath temp_sub_resource_dir_;
 153 };
 154
 155 // TODO(jnd): 1. Some encodings are missing here. It'll be added later. See
 156 // http://crbug.com/13306.
 157 // 2. Add more files with multiple encoding name variants for each canonical
 158 // encoding name). Webkit layout tests cover some, but testing in the UI test is
 159 // also necessary.
 160 IN_PROC_BROWSER_TEST_P(BrowserEncodingTest, TestEncodingAliasMapping) {
 161   const char* const kAliasTestDir = "alias_mapping";
 162
 163   base::FilePath test_dir_path = base::FilePath(kTestDir).AppendASCII(
 164       kAliasTestDir);
 165   base::FilePath test_file_path(test_dir_path);
 166   test_file_path = test_file_path.AppendASCII(
 167       GetParam().file_name);
 168
 169   GURL url = net::URLRequestMockHTTPJob::GetMockUrl(test_file_path);
 170   ui_test_utils::NavigateToURL(browser(), url);
 171   EXPECT_EQ(GetParam().encoding_name,
 172             browser()->tab_strip_model()->GetActiveWebContents()->
 173                 GetEncoding());
 174 }
 175
 176 INSTANTIATE_TEST_CASE_P(EncodingAliases,
 177                         BrowserEncodingTest,
 178                         testing::ValuesIn(kEncodingTestDatas));
 179
 180 // Marked as flaky: see  http://crbug.com/44668
 181 IN_PROC_BROWSER_TEST_F(BrowserEncodingTest, TestOverrideEncoding) {
 182   const char* const kTestFileName = "gb18030_with_iso88591_meta.html";
 183   const char* const kExpectedFileName =
 184       "expected_gb18030_saved_from_iso88591_meta.html";
 185   const char* const kOverrideTestDir = "user_override";
 186
 187   base::FilePath test_dir_path =
 188       base::FilePath(kTestDir).AppendASCII(kOverrideTestDir);
 189   test_dir_path = test_dir_path.AppendASCII(kTestFileName);
 190   GURL url = net::URLRequestMockHTTPJob::GetMockUrl(test_dir_path);
 191   ui_test_utils::NavigateToURL(browser(), url);
 192   content::WebContents* web_contents =
 193       browser()->tab_strip_model()->GetActiveWebContents();
 194   EXPECT_EQ("windows-1252", web_contents->GetEncoding());
 195
 196   // Override the encoding to "gb18030".
 197   const std::string selected_encoding =
 198       CharacterEncoding::GetCanonicalEncodingNameByAliasName("gb18030");
 199   content::TestNavigationObserver navigation_observer(web_contents);
 200   web_contents->SetOverrideEncoding(selected_encoding);
 201   navigation_observer.Wait();
 202   EXPECT_EQ("gb18030", web_contents->GetEncoding());
 203
 204   base::FilePath expected_filename =
 205       base::FilePath().AppendASCII(kOverrideTestDir).AppendASCII(
 206           kExpectedFileName);
 207   SaveAndCompare(kTestFileName, expected_filename);
 208 }
 209
 210 // The following encodings are excluded from the auto-detection test because
 211 // it's a known issue that the current encoding detector does not detect them:
 212 // ISO-8859-4
 213 // ISO-8859-13
 214 // KOI8-U
 215 // macintosh
 216 // windows-874
 217 // windows-1252
 218 // windows-1253
 219 // windows-1257
 220 // windows-1258
 221
 222 // For Hebrew, the expected encoding value is ISO-8859-8-I. See
 223 // http://crbug.com/2927 for more details.
 224 //
 225 // This test fails frequently on the win_rel trybot. See http://crbug.com/122053
 226 // It also times out frequently on Mac dbg. See http://crbug.com/351325
 227 #if defined(OS_WIN) || defined(OS_MACOSX)
 228 #define MAYBE_TestEncodingAutoDetect DISABLED_TestEncodingAutoDetect
 229 #else
 230 #define MAYBE_TestEncodingAutoDetect TestEncodingAutoDetect
 231 #endif
 232 // TODO(phajdan.jr): See if fix for http://crbug.com/122053 would help here.
 233 IN_PROC_BROWSER_TEST_F(BrowserEncodingTest, MAYBE_TestEncodingAutoDetect) {
 234   struct EncodingAutoDetectTestData {
 235     const char* test_file_name;   // File name of test data.
 236     const char* expected_result;  // File name of expected results.
 237     const char* expected_encoding;   // expected encoding.
 238   };
 239   const EncodingAutoDetectTestData kTestDatas[] = {
 240       { "Big5_with_no_encoding_specified.html",
 241         "expected_Big5_saved_from_no_encoding_specified.html",
 242         "Big5" },
 243       { "gb18030_with_no_encoding_specified.html",
 244         "expected_gb18030_saved_from_no_encoding_specified.html",
 245         "gb18030" },
 246       { "iso-8859-1_with_no_encoding_specified.html",
 247         "expected_iso-8859-1_saved_from_no_encoding_specified.html",
 248         "windows-1252" },
 249       { "ISO-8859-5_with_no_encoding_specified.html",
 250         "expected_ISO-8859-5_saved_from_no_encoding_specified.html",
 251         "ISO-8859-5" },
 252       { "ISO-8859-6_with_no_encoding_specified.html",
 253         "expected_ISO-8859-6_saved_from_no_encoding_specified.html",
 254         "ISO-8859-6" },
 255       { "ISO-8859-7_with_no_encoding_specified.html",
 256         "expected_ISO-8859-7_saved_from_no_encoding_specified.html",
 257         "ISO-8859-7" },
 258       { "ISO-8859-8_with_no_encoding_specified.html",
 259         "expected_ISO-8859-8_saved_from_no_encoding_specified.html",
 260         "ISO-8859-8-I" },
 261       { "KOI8-R_with_no_encoding_specified.html",
 262         "expected_KOI8-R_saved_from_no_encoding_specified.html",
 263         "KOI8-R" },
 264       { "Shift-JIS_with_no_encoding_specified.html",
 265         "expected_Shift-JIS_saved_from_no_encoding_specified.html",
 266         "Shift_JIS" },
 267       { "UTF-8_with_no_encoding_specified.html",
 268         "expected_UTF-8_saved_from_no_encoding_specified.html",
 269         "UTF-8" },
 270       { "EUC-KR_with_no_encoding_specified.html",
 271         "expected_EUC-KR_saved_from_no_encoding_specified.html",
 272         "EUC-KR" },
 273       { "windows-1251_with_no_encoding_specified.html",
 274         "expected_windows-1251_saved_from_no_encoding_specified.html",
 275         "windows-1251" },
 276       { "windows-1254_with_no_encoding_specified.html",
 277         "expected_windows-1254_saved_from_no_encoding_specified.html",
 278         "windows-1254" },
 279       { "windows-1255_with_no_encoding_specified.html",
 280         "expected_windows-1255_saved_from_no_encoding_specified.html",
 281         "windows-1255" },
 282       { "windows-1256_with_no_encoding_specified.html",
 283         "expected_windows-1256_saved_from_no_encoding_specified.html",
 284         "windows-1256" }
 285     };
 286   const char* const kAutoDetectDir = "auto_detect";
 287   // Directory of the files of expected results.
 288   const char* const kExpectedResultDir = "expected_results";
 289
 290   base::FilePath test_dir_path =
 291       base::FilePath(kTestDir).AppendASCII(kAutoDetectDir);
 292
 293   // Set the default charset to one of encodings not supported by the current
 294   // auto-detector (Please refer to the above comments) to make sure we
 295   // incorrectly decode the page. Now we use ISO-8859-4.
 296   browser()->profile()->GetPrefs()->SetString(prefs::kDefaultCharset,
 297                                               "ISO-8859-4");
 298
 299   content::WebContents* web_contents =
 300       browser()->tab_strip_model()->GetActiveWebContents();
 301   for (size_t i = 0; i < arraysize(kTestDatas); ++i) {
 302     // Disable auto detect if it is on.
 303     browser()->profile()->GetPrefs()->SetBoolean(
 304         prefs::kWebKitUsesUniversalDetector, false);
 305
 306     base::FilePath test_file_path(test_dir_path);
 307     test_file_path = test_file_path.AppendASCII(kTestDatas[i].test_file_name);
 308     GURL url = net::URLRequestMockHTTPJob::GetMockUrl(test_file_path);
 309     ui_test_utils::NavigateToURL(browser(), url);
 310
 311     // Get the encoding used for the page, it must be the default charset we
 312     // just set.
 313     EXPECT_EQ("ISO-8859-4", web_contents->GetEncoding());
 314
 315     // Enable the encoding auto detection.
 316     browser()->profile()->GetPrefs()->SetBoolean(
 317         prefs::kWebKitUsesUniversalDetector, true);
 318
 319     content::TestNavigationObserver observer(web_contents);
 320     chrome::Reload(browser(), CURRENT_TAB);
 321     observer.Wait();
 322
 323     // Re-get the encoding of page. It should return the real encoding now.
 324     EXPECT_EQ(kTestDatas[i].expected_encoding, web_contents->GetEncoding());
 325
 326     // Dump the page, the content of dump page should be equal with our expect
 327     // result file.
 328     base::FilePath expected_result_file_name =
 329         base::FilePath().AppendASCII(kAutoDetectDir).
 330         AppendASCII(kExpectedResultDir).
 331         AppendASCII(kTestDatas[i].expected_result);
 332     SaveAndCompare(kTestDatas[i].test_file_name, expected_result_file_name);
 333   }
 334 }