Remove android_java_ui as it is not used

chrome/browser/download/download_target_determiner_unittest.cc

 // Copyright (c) 2012 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 <stddef.h>
 #include <stdint.h>
 
 #include "base/at_exit.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 494 matching lines @@
       base::FilePath()
       .AppendASCII("overridden")
       .Append(path.BaseName());
   if (new_path.MatchesExtension(FILE_PATH_LITERAL(".remove")))
     new_path = new_path.RemoveExtension();
   callback.Run(new_path, DownloadPathReservationTracker::UNIQUIFY);
 }
 
 TEST_F(DownloadTargetDeterminerTest, Basic) {
   const DownloadTestCase kBasicTestCases[] = {
-      {// 0: Automatic Safe
-       AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
-       "text/plain", FILE_PATH_LITERAL(""),
+    {// 0: Automatic Safe
+     AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+     DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+     "text/plain", FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+     FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
-       EXPECT_CRDOWNLOAD},
+     EXPECT_CRDOWNLOAD},
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
-      {// 1: Save_As Safe
-       SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
-       "text/plain", FILE_PATH_LITERAL(""),
+#if !defined(OS_ANDROID)
+    {// 1: Save_As Safe
+     SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+     DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+     "text/plain", FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
+     FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
-       EXPECT_CRDOWNLOAD},
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
+     EXPECT_CRDOWNLOAD},
+#endif  // !defined(OS_ANDROID)
 
-      {// 2: Automatic Dangerous
-       AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
-       DownloadFileType::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx",
-       "", FILE_PATH_LITERAL(""),
+    {// 2: Automatic Dangerous
+     AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
+     DownloadFileType::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx", "",
+     FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+     FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
-       EXPECT_UNCONFIRMED},
+     EXPECT_UNCONFIRMED},
 
-      {// 3: Forced Safe
-       FORCED, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt", "",
-       FILE_PATH_LITERAL("forced-foo.txt"),
+    {// 3: Forced Safe
+     FORCED, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+     DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt", "",
+     FILE_PATH_LITERAL("forced-foo.txt"),
 
-       FILE_PATH_LITERAL("forced-foo.txt"),
-       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+     FILE_PATH_LITERAL("forced-foo.txt"),
+     DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
-       EXPECT_LOCAL_PATH},
+     EXPECT_LOCAL_PATH},
   };
 
   // The test assumes that .crx files have a danger level of
   // ALLOW_ON_USER_GESTURE.
   ASSERT_EQ(DownloadFileType::ALLOW_ON_USER_GESTURE,
             Policies()->GetFileDangerLevel(
                 base::FilePath(FILE_PATH_LITERAL("foo.crx"))));
   RunTestCasesWithActiveItem(kBasicTestCases, arraysize(kBasicTestCases));
 }
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
+#if !defined(OS_ANDROID)
 TEST_F(DownloadTargetDeterminerTest, CancelSaveAs) {
   const DownloadTestCase kCancelSaveAsTestCases[] = {
       {// 0: Save_As Safe, Cancelled.
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
        DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
        "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL(""), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_LOCAL_PATH}};
   ON_CALL(*delegate(), PromptUserForDownloadPath(_, _, _))
       .WillByDefault(WithArg<2>(ScheduleCallback(base::FilePath())));
   RunTestCasesWithActiveItem(kCancelSaveAsTestCases,
                              arraysize(kCancelSaveAsTestCases));
 }
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
+#endif  // !defined(OS_ANDROID)
 
 // The SafeBrowsing check is performed early. Make sure that a download item
 // that has been marked as DANGEROUS_URL behaves correctly.
 TEST_F(DownloadTargetDeterminerTest, DangerousUrl) {
   const DownloadTestCase kSafeBrowsingTestCases[] = {
-      {// 0: Automatic Dangerous URL
-       AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
-       DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.txt",
-       "", FILE_PATH_LITERAL(""),
+    {// 0: Automatic Dangerous URL
+     AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
+     DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.txt", "",
+     FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+     FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
-       EXPECT_UNCONFIRMED},
+     EXPECT_UNCONFIRMED},
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
-      {// 1: Save As Dangerous URL
-       SAVE_AS, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
-       DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.txt",
-       "", FILE_PATH_LITERAL(""),
+#if !defined(OS_ANDROID)
+    {// 1: Save As Dangerous URL
+     SAVE_AS, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
+     DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.txt", "",
+     FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
+     FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
-       EXPECT_UNCONFIRMED},
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
+     EXPECT_UNCONFIRMED},
+#endif  // !defined(OS_ANDROID)
 
-      {// 2: Forced Dangerous URL
-       FORCED, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
-       DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.txt",
-       "", FILE_PATH_LITERAL("forced-foo.txt"),
+    {// 2: Forced Dangerous URL
+     FORCED, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
+     DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.txt", "",
+     FILE_PATH_LITERAL("forced-foo.txt"),
 
-       FILE_PATH_LITERAL("forced-foo.txt"),
-       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+     FILE_PATH_LITERAL("forced-foo.txt"),
+     DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
-       EXPECT_UNCONFIRMED},
+     EXPECT_UNCONFIRMED},
 
-      {// 3: Automatic Dangerous URL + Dangerous file. Dangerous URL takes
-       // precedence.
-       AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
-       DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.html",
-       "", FILE_PATH_LITERAL(""),
+    {// 3: Automatic Dangerous URL + Dangerous file. Dangerous URL takes
+     // precedence.
+     AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
+     DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.html",
+     "", FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.html"),
-       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+     FILE_PATH_LITERAL("foo.html"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
-       EXPECT_UNCONFIRMED},
+     EXPECT_UNCONFIRMED},
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
-      {// 4: Save As Dangerous URL + Dangerous file
-       SAVE_AS, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
-       DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.html",
-       "", FILE_PATH_LITERAL(""),
+#if !defined(OS_ANDROID)
+    {// 4: Save As Dangerous URL + Dangerous file
+     SAVE_AS, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
+     DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.html",
+     "", FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.html"), DownloadItem::TARGET_DISPOSITION_PROMPT,
+     FILE_PATH_LITERAL("foo.html"), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
-       EXPECT_UNCONFIRMED},
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
+     EXPECT_UNCONFIRMED},
+#endif  // !defined(OS_ANDROID)
 
-      {// 5: Forced Dangerous URL + Dangerous file
-       FORCED, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
-       DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.html",
-       "", FILE_PATH_LITERAL("forced-foo.html"),
+    {// 5: Forced Dangerous URL + Dangerous file
+     FORCED, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
+     DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.html",
+     "", FILE_PATH_LITERAL("forced-foo.html"),
 
-       FILE_PATH_LITERAL("forced-foo.html"),
-       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+     FILE_PATH_LITERAL("forced-foo.html"),
+     DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
-       EXPECT_UNCONFIRMED},
+     EXPECT_UNCONFIRMED},
   };
 
   ON_CALL(*delegate(), CheckDownloadUrl(_, _, _))
       .WillByDefault(WithArg<2>(ScheduleCallback(
           content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL)));
   RunTestCasesWithActiveItem(kSafeBrowsingTestCases,
                              arraysize(kSafeBrowsingTestCases));
 }
 
 // The SafeBrowsing check is performed early. Make sure that a download item
 // that has been marked as MAYBE_DANGEROUS_CONTENT behaves correctly.
 TEST_F(DownloadTargetDeterminerTest, MaybeDangerousContent) {
   const DownloadTestCase kSafeBrowsingTestCases[] = {
-      {// 0: Automatic Maybe dangerous content
-       AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
-       DownloadFileType::ALLOW_ON_USER_GESTURE,
-       "http://phishing.example.com/foo.crx", "", FILE_PATH_LITERAL(""),
+    {// 0: Automatic Maybe dangerous content
+     AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
+     DownloadFileType::ALLOW_ON_USER_GESTURE,
+     "http://phishing.example.com/foo.crx", "", FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+     FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
-       EXPECT_UNCONFIRMED},
+     EXPECT_UNCONFIRMED},
 
-      {// 1: Automatic Maybe dangerous content with DANGEROUS type.
-       AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
-       DownloadFileType::DANGEROUS, "http://phishing.example.com/foo.swf", "",
-       FILE_PATH_LITERAL(""),
+    {// 1: Automatic Maybe dangerous content with DANGEROUS type.
+     AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
+     DownloadFileType::DANGEROUS, "http://phishing.example.com/foo.swf", "",
+     FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.swf"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+     FILE_PATH_LITERAL("foo.swf"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
-       EXPECT_UNCONFIRMED},
+     EXPECT_UNCONFIRMED},
 
+#if !defined(OS_ANDROID)
+    {// 2: Save As Maybe dangerous content
+     SAVE_AS, content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
+     DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.crx", "",
+     FILE_PATH_LITERAL(""),
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
-      {// 2: Save As Maybe dangerous content
-       SAVE_AS, content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
-       DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.crx",
-       "", FILE_PATH_LITERAL(""),
+     FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
-       FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_PROMPT,
+     EXPECT_UNCONFIRMED},
+#endif  // !defined(OS_ANDROID)
 
-       EXPECT_UNCONFIRMED},
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
+    {// 3: Forced Maybe dangerous content
+     FORCED, content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
+     DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.crx", "",
+     FILE_PATH_LITERAL("forced-foo.crx"),
 
-      {// 3: Forced Maybe dangerous content
-       FORCED, content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
-       DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.crx",
-       "", FILE_PATH_LITERAL("forced-foo.crx"),
+     FILE_PATH_LITERAL("forced-foo.crx"),
+     DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
-       FILE_PATH_LITERAL("forced-foo.crx"),
-       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
-
-       EXPECT_UNCONFIRMED},
+     EXPECT_UNCONFIRMED},
   };
 
   // Test assumptions:
   ASSERT_EQ(DownloadFileType::ALLOW_ON_USER_GESTURE,
             Policies()->GetFileDangerLevel(
                 base::FilePath(FILE_PATH_LITERAL("foo.crx"))));
   ASSERT_EQ(DownloadFileType::DANGEROUS,
             Policies()->GetFileDangerLevel(
                 base::FilePath(FILE_PATH_LITERAL("foo.swf"))));
 
   ON_CALL(*delegate(), CheckDownloadUrl(_, _, _))
       .WillByDefault(WithArg<2>(ScheduleCallback(
           content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT)));
   RunTestCasesWithActiveItem(kSafeBrowsingTestCases,
                              arraysize(kSafeBrowsingTestCases));
 }
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
+#if !defined(OS_ANDROID)
 // Test whether the last saved directory is used for 'Save As' downloads.
 TEST_F(DownloadTargetDeterminerTest, LastSavePath) {
   const DownloadTestCase kLastSavePathTestCasesPre[] = {
       {// 0: If the last save path is empty, then the default download directory
        //    should be used.
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
        DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
        "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
@@ skipping 68 matching lines @@
     download_prefs()->SetSaveFilePath(last_selected_dir);
     EXPECT_CALL(*delegate(), PromptUserForDownloadPath(
         _, last_selected_dir.AppendASCII("foo.txt"), _));
     EXPECT_CALL(*delegate(), DetermineLocalPath(_, virtual_path, _))
         .WillOnce(WithArg<2>(ScheduleCallback(
             GetPathInDownloadDir(FILE_PATH_LITERAL("bar.txt")))));
     RunTestCasesWithActiveItem(kLastSavePathTestCasesVirtual,
                                arraysize(kLastSavePathTestCasesVirtual));
   }
 }
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
+#endif  // !defined(OS_ANDROID)
 
 // These tests are run with the default downloads folder set to a virtual
 // directory.
 TEST_F(DownloadTargetDeterminerTest, DefaultVirtual) {
   // The default download directory is the virutal path.
   download_prefs()->SetDownloadPath(test_virtual_dir());
 
   {
     SCOPED_TRACE(testing::Message() << "Automatic Safe Download");
     const DownloadTestCase kAutomaticDownloadToVirtualDir = {
         AUTOMATIC,
         content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
         DownloadFileType::NOT_DANGEROUS,
         "http://example.com/foo.txt",
         "text/plain",
         FILE_PATH_LITERAL(""),
 
         FILE_PATH_LITERAL("foo-local.txt"),
         DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
         EXPECT_LOCAL_PATH};
     EXPECT_CALL(*delegate(), DetermineLocalPath(_, _, _))
         .WillOnce(WithArg<2>(ScheduleCallback(
             GetPathInDownloadDir(FILE_PATH_LITERAL("foo-local.txt")))));
     RunTestCasesWithActiveItem(&kAutomaticDownloadToVirtualDir, 1);
   }
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
+#if !defined(OS_ANDROID)
   {
     SCOPED_TRACE(testing::Message() << "Save As to virtual directory");
     const DownloadTestCase kSaveAsToVirtualDir = {
         SAVE_AS,
         content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
         DownloadFileType::NOT_DANGEROUS,
         "http://example.com/bar.txt",
         "text/plain",
         FILE_PATH_LITERAL(""),
 
@@ skipping 24 matching lines @@
         FILE_PATH_LITERAL("foo-x.txt"),
         DownloadItem::TARGET_DISPOSITION_PROMPT,
 
         EXPECT_CRDOWNLOAD};
     EXPECT_CALL(*delegate(), PromptUserForDownloadPath(
         _, test_virtual_dir().AppendASCII("bar.txt"), _))
         .WillOnce(WithArg<2>(ScheduleCallback(
             GetPathInDownloadDir(FILE_PATH_LITERAL("foo-x.txt")))));
     RunTestCasesWithActiveItem(&kSaveAsToLocalDir, 1);
   }
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
+#endif  // !defined(OS_ANDROID)
 
   {
     SCOPED_TRACE(testing::Message() << "Forced safe download");
     const DownloadTestCase kForcedSafe = {
         FORCED,
         content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
         DownloadFileType::NOT_DANGEROUS,
         "http://example.com/foo.txt",
         "",
         FILE_PATH_LITERAL("forced-foo.txt"),
 
         FILE_PATH_LITERAL("forced-foo.txt"),
         DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
         EXPECT_LOCAL_PATH};
     RunTestCasesWithActiveItem(&kForcedSafe, 1);
   }
 }
 
 // Test that an inactive download will still get a virtual or local download
 // path.
 TEST_F(DownloadTargetDeterminerTest, InactiveDownload) {
   const DownloadTestCase kInactiveTestCases[] = {
-      {AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
-       "text/plain", FILE_PATH_LITERAL(""),
+    {AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+     DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+     "text/plain", FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+     FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
-       EXPECT_CRDOWNLOAD},
+     EXPECT_CRDOWNLOAD},
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
-      {SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
-       "text/plain", FILE_PATH_LITERAL(""),
+#if !defined(OS_ANDROID)
+    {SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+     DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+     "text/plain", FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
+     FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
-       EXPECT_CRDOWNLOAD}
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
+     EXPECT_CRDOWNLOAD}
+#endif  // !defined(OS_ANDROID)
   };
 
   for (size_t i = 0; i < arraysize(kInactiveTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "Running test case " << i);
     const DownloadTestCase& test_case = kInactiveTestCases[i];
     std::unique_ptr<content::MockDownloadItem> item(
         CreateActiveDownloadItem(i, test_case));
     EXPECT_CALL(*item.get(), GetState())
         .WillRepeatedly(Return(content::DownloadItem::CANCELLED));
 
@@ skipping 49 matching lines @@
       .WillOnce(WithArg<2>(ScheduleCallback(base::FilePath())));
   RunTestCasesWithActiveItem(kLocalPathFailedCases,
                              arraysize(kLocalPathFailedCases));
 }
 
 // Downloads that have a danger level of ALLOW_ON_USER_GESTURE should be marked
 // as safe depending on whether there was a user gesture associated with the
 // download and whether the referrer was visited prior to today.
 TEST_F(DownloadTargetDeterminerTest, VisitedReferrer) {
   const DownloadTestCase kVisitedReferrerCases[] = {
-      // http://visited.example.com/ is added to the history as a visit that
-      // happened prior to today.
-      {// 0: Safe download due to visiting referrer before.
-       AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       DownloadFileType::NOT_DANGEROUS, "http://visited.example.com/foo.crx",
-       "application/xml", FILE_PATH_LITERAL(""),
+    // http://visited.example.com/ is added to the history as a visit that
+    // happened prior to today.
+    {// 0: Safe download due to visiting referrer before.
+     AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+     DownloadFileType::NOT_DANGEROUS, "http://visited.example.com/foo.crx",
+     "application/xml", FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+     FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
-       EXPECT_CRDOWNLOAD},
+     EXPECT_CRDOWNLOAD},
 
-      {// 1: Dangerous due to not having visited referrer before.
-       AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
-       DownloadFileType::ALLOW_ON_USER_GESTURE,
-       "http://not-visited.example.com/foo.crx", "application/xml",
-       FILE_PATH_LITERAL(""),
+    {// 1: Dangerous due to not having visited referrer before.
+     AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
+     DownloadFileType::ALLOW_ON_USER_GESTURE,
+     "http://not-visited.example.com/foo.crx", "application/xml",
+     FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+     FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
-       EXPECT_UNCONFIRMED},
+     EXPECT_UNCONFIRMED},
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
-      {// 2: Safe because the user is being prompted.
-       SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       DownloadFileType::NOT_DANGEROUS,
-       "http://not-visited.example.com/foo.crx", "application/xml",
-       FILE_PATH_LITERAL(""),
+#if !defined(OS_ANDROID)
+    {// 2: Safe because the user is being prompted.
+     SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+     DownloadFileType::NOT_DANGEROUS, "http://not-visited.example.com/foo.crx",
+     "application/xml", FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_PROMPT,
+     FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
-       EXPECT_CRDOWNLOAD},
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
+     EXPECT_CRDOWNLOAD},
+#endif  // !defined(OS_ANDROID)
 
-      {// 3: Safe because of forced path.
-       FORCED, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       DownloadFileType::NOT_DANGEROUS,
-       "http://not-visited.example.com/foo.crx", "application/xml",
-       FILE_PATH_LITERAL("foo.crx"),
+    {// 3: Safe because of forced path.
+     FORCED, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+     DownloadFileType::NOT_DANGEROUS, "http://not-visited.example.com/foo.crx",
+     "application/xml", FILE_PATH_LITERAL("foo.crx"),
 
-       FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+     FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
-       EXPECT_LOCAL_PATH},
+     EXPECT_LOCAL_PATH},
   };
 
   // This test assumes that the danger level of .crx files is
   // ALLOW_ON_USER_GESTURE.
   ASSERT_EQ(DownloadFileType::ALLOW_ON_USER_GESTURE,
             Policies()->GetFileDangerLevel(
                 base::FilePath(FILE_PATH_LITERAL("foo.crx"))));
 
   // First the history service must exist.
   ASSERT_TRUE(profile()->CreateHistoryService(false, false));
@@ skipping 125 matching lines @@
     }
 
     std::unique_ptr<content::MockDownloadItem> item(
         CreateActiveDownloadItem(1, download_test_case));
     EXPECT_CALL(*item, GetTransitionType())
         .WillRepeatedly(Return(test_case.page_transition));
     RunTestCase(download_test_case, base::FilePath(), item.get());
   }
 }
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
+#if !defined(OS_ANDROID)
 // These test cases are run with "Prompt for download" user preference set to
 // true.
 TEST_F(DownloadTargetDeterminerTest, PromptAlways) {
   const DownloadTestCase kPromptingTestCases[] = {
       {// 0: Safe Automatic - Should prompt because of "Prompt for download"
        //    preference setting.
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
        DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
        "text/plain", FILE_PATH_LITERAL(""),
 
@@ skipping 21 matching lines @@
 
        EXPECT_CRDOWNLOAD},
   };
 
   SetPromptForDownload(true);
   EnableAutoOpenBasedOnExtension(
       base::FilePath(FILE_PATH_LITERAL("dummy.dummy")));
   RunTestCasesWithActiveItem(kPromptingTestCases,
                              arraysize(kPromptingTestCases));
 }
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
+#endif  // !defined(OS_ANDROID)
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
 // These test cases are run with "Prompt for download" user preference set to
 // true. Automatic extension downloads shouldn't cause prompting.
 // Android doesn't support extensions.
 TEST_F(DownloadTargetDeterminerTest, PromptAlways_Extension) {
   const DownloadTestCase kPromptingTestCases[] = {
     {// 0: Automatic Browser Extension download. - Shouldn't prompt for browser
      //    extension downloads even if "Prompt for download" preference is set.
      AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
@@ skipping 62 matching lines @@
   SetManagedDownloadPath(test_download_dir());
   ASSERT_TRUE(download_prefs()->IsDownloadPathManaged());
   RunTestCasesWithActiveItem(kManagedPathTestCases,
                              arraysize(kManagedPathTestCases));
 }
 
 // Test basic functionality supporting extensions that want to override download
 // filenames.
 TEST_F(DownloadTargetDeterminerTest, NotifyExtensionsSafe) {
   const DownloadTestCase kNotifyExtensionsTestCases[] = {
-      {// 0: Automatic Safe
-       AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
-       "text/plain", FILE_PATH_LITERAL(""),
+    {// 0: Automatic Safe
+     AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+     DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+     "text/plain", FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("overridden/foo.txt"),
-       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+     FILE_PATH_LITERAL("overridden/foo.txt"),
+     DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
-       EXPECT_CRDOWNLOAD},
+     EXPECT_CRDOWNLOAD},
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
-      {// 1: Save_As Safe
-       SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
-       "text/plain", FILE_PATH_LITERAL(""),
+#if !defined(OS_ANDROID)
+    {// 1: Save_As Safe
+     SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+     DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+     "text/plain", FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("overridden/foo.txt"),
-       DownloadItem::TARGET_DISPOSITION_PROMPT,
+     FILE_PATH_LITERAL("overridden/foo.txt"),
+     DownloadItem::TARGET_DISPOSITION_PROMPT,
 
-       EXPECT_CRDOWNLOAD},
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
+     EXPECT_CRDOWNLOAD},
+#endif  // !defined(OS_ANDROID)
 
-      {// 2: Automatic Dangerous
-       AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
-       DownloadFileType::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx",
-       "", FILE_PATH_LITERAL(""),
+    {// 2: Automatic Dangerous
+     AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
+     DownloadFileType::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx", "",
+     FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("overridden/foo.crx"),
-       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+     FILE_PATH_LITERAL("overridden/foo.crx"),
+     DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
-       EXPECT_UNCONFIRMED},
+     EXPECT_UNCONFIRMED},
 
-      {// 3: Forced Safe
-       FORCED, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt", "",
-       FILE_PATH_LITERAL("forced-foo.txt"),
+    {// 3: Forced Safe
+     FORCED, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+     DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt", "",
+     FILE_PATH_LITERAL("forced-foo.txt"),
 
-       FILE_PATH_LITERAL("forced-foo.txt"),
-       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+     FILE_PATH_LITERAL("forced-foo.txt"),
+     DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
-       EXPECT_LOCAL_PATH},
+     EXPECT_LOCAL_PATH},
   };
 
   ON_CALL(*delegate(), NotifyExtensions(_, _, _))
       .WillByDefault(Invoke(&NotifyExtensionsOverridePath));
   RunTestCasesWithActiveItem(kNotifyExtensionsTestCases,
                              arraysize(kNotifyExtensionsTestCases));
 }
 
 // Test that filenames provided by extensions are passed into SafeBrowsing
 // checks and dangerous download checks.
@@ skipping 74 matching lines @@
       .WillOnce(WithArg<2>(
           ScheduleCallback2(overridden_path,
                             DownloadPathReservationTracker::PROMPT)));
   EXPECT_CALL(*delegate(), ReserveVirtualPath(
       _, full_overridden_path, true, DownloadPathReservationTracker::PROMPT, _))
       .WillOnce(WithArg<4>(
           ScheduleCallback2(full_overridden_path, true)));
   RunTestCase(test_case, base::FilePath(), item.get());
 }
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
+#if !defined(OS_ANDROID)
 // Test that relative paths returned by extensions are always relative to the
 // default downloads path.
 TEST_F(DownloadTargetDeterminerTest, NotifyExtensionsDefaultPath) {
   const DownloadTestCase kNotifyExtensionsTestCase = {
       SAVE_AS,
       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
       DownloadFileType::NOT_DANGEROUS,
       "http://example.com/foo.txt",
       "text/plain",
       FILE_PATH_LITERAL(""),
@@ skipping 16 matching lines @@
   EXPECT_CALL(*delegate(), NotifyExtensions(_, _, _))
       .WillOnce(WithArg<2>(
           ScheduleCallback2(overridden_path,
                             DownloadPathReservationTracker::UNIQUIFY)));
   EXPECT_CALL(*delegate(),
               PromptUserForDownloadPath(_, full_overridden_path, _))
       .WillOnce(WithArg<2>(
           ScheduleCallback(full_overridden_path)));
   RunTestCase(test_case, base::FilePath(), item.get());
 }
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
+#endif  // !defined(OS_ANDROID)
 
 TEST_F(DownloadTargetDeterminerTest, InitialVirtualPathUnsafe) {
   const base::FilePath::CharType* kInitialPath =
       FILE_PATH_LITERAL("some_path/bar.html");
 
   const DownloadTestCase kInitialPathTestCase = {
       // 0: Save As Save. The path generated based on the DownloadItem is safe,
       // but the initial path is unsafe. However, the download is not considered
       // dangerous since the user has been prompted.
       SAVE_AS,
@@ skipping 147 matching lines @@
   const base::FilePath::CharType* kInitialPath =
       FILE_PATH_LITERAL("some_path/bar.txt");
 
   const DownloadTestCase kResumedTestCases[] = {
       {// 0: Automatic Safe
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
        DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
        "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.txt"),
-#if BUILDFLAG(ANDROID_JAVA_UI)
+#if defined(OS_ANDROID)
        DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 #else
        DownloadItem::TARGET_DISPOSITION_PROMPT,
 #endif
        EXPECT_CRDOWNLOAD},
 
       {// 1: Save_As Safe
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
        DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
        "text/plain", FILE_PATH_LITERAL(""),
 
        kInitialPath, DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_CRDOWNLOAD},
 
       {
           // 2: Automatic Dangerous
           AUTOMATIC,
-#if BUILDFLAG(ANDROID_JAVA_UI)
+#if defined(OS_ANDROID)
           // If we don't prompt user, the file will be treated as dangerous.
           content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
           DownloadFileType::ALLOW_ON_USER_GESTURE,
 #else
           content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
           DownloadFileType::NOT_DANGEROUS,
 #endif
           "http://example.com/foo.crx", "", FILE_PATH_LITERAL(""),
 
           FILE_PATH_LITERAL("foo.crx"),
-#if BUILDFLAG(ANDROID_JAVA_UI)
+#if defined(OS_ANDROID)
           DownloadItem::TARGET_DISPOSITION_OVERWRITE,
           // Dangerous download will have an unconfirmed intermediate file name.
           EXPECT_UNCONFIRMED,
 #else
           DownloadItem::TARGET_DISPOSITION_PROMPT, EXPECT_CRDOWNLOAD,
 #endif
       },
   };
 
   // The test assumes that .xml files have a danger level of
   // ALLOW_ON_USER_GESTURE.
   ASSERT_EQ(DownloadFileType::ALLOW_ON_USER_GESTURE,
             Policies()->GetFileDangerLevel(
                 base::FilePath(FILE_PATH_LITERAL("foo.crx"))));
   for (size_t i = 0; i < arraysize(kResumedTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "Running test case " << i);
     download_prefs()->SetSaveFilePath(test_download_dir());
     const DownloadTestCase& test_case = kResumedTestCases[i];
     base::FilePath expected_path =
         GetPathInDownloadDir(test_case.expected_local_path);
     std::unique_ptr<content::MockDownloadItem> item(
         CreateActiveDownloadItem(i, test_case));
     ON_CALL(*item.get(), GetLastReason())
         .WillByDefault(Return(
             content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE));
     EXPECT_CALL(*delegate(), NotifyExtensions(_, _, _))
         .Times(test_case.test_type == AUTOMATIC ? 1 : 0);
     EXPECT_CALL(*delegate(), ReserveVirtualPath(_, expected_path, false, _, _));
-#if BUILDFLAG(ANDROID_JAVA_UI)
+#if defined(OS_ANDROID)
     EXPECT_CALL(*delegate(), PromptUserForDownloadPath(_, expected_path, _))
         .Times(0);
 #else
     EXPECT_CALL(*delegate(), PromptUserForDownloadPath(_, expected_path, _));
 #endif
     EXPECT_CALL(*delegate(), DetermineLocalPath(_, expected_path, _));
     EXPECT_CALL(*delegate(), CheckDownloadUrl(_, expected_path, _));
     RunTestCase(test_case, GetPathInDownloadDir(kInitialPath), item.get());
   }
 }
@@ skipping 451 matching lines @@
   EXPECT_CALL(mock_plugin_filter_, MockPluginAvailable(browser_plugin.path()))
       .WillRepeatedly(Return(false));
   target_info = RunDownloadTargetDeterminer(
       GetPathInDownloadDir(kInitialPath), item.get());
   EXPECT_FALSE(target_info->is_filetype_handled_safely);
 }
 
 #endif  // BUILDFLAG(ENABLE_PLUGINS)
 
 }  // namespace