chrome/browser/shell_integration_unittest.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 "chrome/browser/shell_integration.h"
   6
   7 #include <algorithm>
   8 #include <cstdlib>
   9 #include <map>
  10
  11 #include "base/base_paths.h"
  12 #include "base/file_util.h"
  13 #include "base/files/file_path.h"
  14 #include "base/files/scoped_temp_dir.h"
  15 #include "base/message_loop/message_loop.h"
  16 #include "base/stl_util.h"
  17 #include "base/strings/string_util.h"
  18 #include "base/strings/utf_string_conversions.h"
  19 #include "base/test/scoped_path_override.h"
  20 #include "chrome/browser/web_applications/web_app.h"
  21 #include "chrome/common/chrome_constants.h"
  22 #include "content/public/test/test_browser_thread.h"
  23 #include "testing/gmock/include/gmock/gmock.h"
  24 #include "testing/gtest/include/gtest/gtest.h"
  25 #include "url/gurl.h"
  26
  27 #if defined(OS_POSIX) && !defined(OS_MACOSX)
  28 #include "base/environment.h"
  29 #include "chrome/browser/shell_integration_linux.h"
  30 #endif
  31
  32 #define FPL FILE_PATH_LITERAL
  33
  34 using content::BrowserThread;
  35 using ::testing::ElementsAre;
  36
  37 #if defined(OS_POSIX) && !defined(OS_MACOSX)
  38 namespace {
  39
  40 // Provides mock environment variables values based on a stored map.
  41 class MockEnvironment : public base::Environment {
  42  public:
  43   MockEnvironment() {}
  44
  45   void Set(const std::string& name, const std::string& value) {
  46     variables_[name] = value;
  47   }
  48
  49   virtual bool GetVar(const char* variable_name, std::string* result) OVERRIDE {
  50     if (ContainsKey(variables_, variable_name)) {
  51       *result = variables_[variable_name];
  52       return true;
  53     }
  54
  55     return false;
  56   }
  57
  58   virtual bool SetVar(const char* variable_name,
  59                       const std::string& new_value) OVERRIDE {
  60     ADD_FAILURE();
  61     return false;
  62   }
  63
  64   virtual bool UnSetVar(const char* variable_name) OVERRIDE {
  65     ADD_FAILURE();
  66     return false;
  67   }
  68
  69  private:
  70   std::map<std::string, std::string> variables_;
  71
  72   DISALLOW_COPY_AND_ASSIGN(MockEnvironment);
  73 };
  74
  75 }  // namespace
  76
  77 TEST(ShellIntegrationTest, GetDataWriteLocation) {
  78   base::MessageLoop message_loop;
  79   content::TestBrowserThread file_thread(BrowserThread::FILE, &message_loop);
  80
  81   // Test that it returns $XDG_DATA_HOME.
  82   {
  83     MockEnvironment env;
  84     env.Set("HOME", "/home/user");
  85     env.Set("XDG_DATA_HOME", "/user/path");
  86     base::FilePath path;
  87     ASSERT_TRUE(ShellIntegrationLinux::GetDataWriteLocation(&env, &path));
  88     EXPECT_EQ(base::FilePath("/user/path"), path);
  89   }
  90
  91   // Test that $XDG_DATA_HOME falls back to $HOME/.local/share.
  92   {
  93     MockEnvironment env;
  94     env.Set("HOME", "/home/user");
  95     base::FilePath path;
  96     ASSERT_TRUE(ShellIntegrationLinux::GetDataWriteLocation(&env, &path));
  97     EXPECT_EQ(base::FilePath("/home/user/.local/share"), path);
  98   }
  99
 100   // Test that if neither $XDG_DATA_HOME nor $HOME are specified, it fails.
 101   {
 102     MockEnvironment env;
 103     base::FilePath path;
 104     ASSERT_FALSE(ShellIntegrationLinux::GetDataWriteLocation(&env, &path));
 105   }
 106 }
 107
 108 TEST(ShellIntegrationTest, GetDataSearchLocations) {
 109   base::MessageLoop message_loop;
 110   content::TestBrowserThread file_thread(BrowserThread::FILE, &message_loop);
 111
 112   // Test that it returns $XDG_DATA_HOME + $XDG_DATA_DIRS.
 113   {
 114     MockEnvironment env;
 115     env.Set("HOME", "/home/user");
 116     env.Set("XDG_DATA_HOME", "/user/path");
 117     env.Set("XDG_DATA_DIRS", "/system/path/1:/system/path/2");
 118     EXPECT_THAT(
 119         ShellIntegrationLinux::GetDataSearchLocations(&env),
 120         ElementsAre(base::FilePath("/user/path"),
 121                     base::FilePath("/system/path/1"),
 122                     base::FilePath("/system/path/2")));
 123   }
 124
 125   // Test that $XDG_DATA_HOME falls back to $HOME/.local/share.
 126   {
 127     MockEnvironment env;
 128     env.Set("HOME", "/home/user");
 129     env.Set("XDG_DATA_DIRS", "/system/path/1:/system/path/2");
 130     EXPECT_THAT(
 131         ShellIntegrationLinux::GetDataSearchLocations(&env),
 132         ElementsAre(base::FilePath("/home/user/.local/share"),
 133                     base::FilePath("/system/path/1"),
 134                     base::FilePath("/system/path/2")));
 135   }
 136
 137   // Test that if neither $XDG_DATA_HOME nor $HOME are specified, it still
 138   // succeeds.
 139   {
 140     MockEnvironment env;
 141     env.Set("XDG_DATA_DIRS", "/system/path/1:/system/path/2");
 142     EXPECT_THAT(
 143         ShellIntegrationLinux::GetDataSearchLocations(&env),
 144         ElementsAre(base::FilePath("/system/path/1"),
 145                     base::FilePath("/system/path/2")));
 146   }
 147
 148   // Test that $XDG_DATA_DIRS falls back to the two default paths.
 149   {
 150     MockEnvironment env;
 151     env.Set("HOME", "/home/user");
 152     env.Set("XDG_DATA_HOME", "/user/path");
 153     EXPECT_THAT(
 154         ShellIntegrationLinux::GetDataSearchLocations(&env),
 155         ElementsAre(base::FilePath("/user/path"),
 156                     base::FilePath("/usr/local/share"),
 157                     base::FilePath("/usr/share")));
 158   }
 159 }
 160
 161 TEST(ShellIntegrationTest, GetExistingShortcutLocations) {
 162   base::FilePath kProfilePath("Profile 1");
 163   const char kExtensionId[] = "test_extension";
 164   const char kTemplateFilename[] = "chrome-test_extension-Profile_1.desktop";
 165   base::FilePath kTemplateFilepath(kTemplateFilename);
 166   const char kNoDisplayDesktopFile[] = "[Desktop Entry]\nNoDisplay=true";
 167
 168   base::MessageLoop message_loop;
 169   content::TestBrowserThread file_thread(BrowserThread::FILE, &message_loop);
 170
 171   // No existing shortcuts.
 172   {
 173     MockEnvironment env;
 174     ShellIntegration::ShortcutLocations result =
 175         ShellIntegrationLinux::GetExistingShortcutLocations(
 176             &env, kProfilePath, kExtensionId);
 177     EXPECT_FALSE(result.on_desktop);
 178     EXPECT_FALSE(result.in_applications_menu);
 179     EXPECT_FALSE(result.in_quick_launch_bar);
 180     EXPECT_FALSE(result.hidden);
 181   }
 182
 183   // Shortcut on desktop.
 184   {
 185     base::ScopedTempDir temp_dir;
 186     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 187     base::FilePath desktop_path = temp_dir.path();
 188
 189     MockEnvironment env;
 190     ASSERT_TRUE(file_util::CreateDirectory(desktop_path));
 191     ASSERT_FALSE(file_util::WriteFile(
 192         desktop_path.AppendASCII(kTemplateFilename),
 193         "", 0));
 194     ShellIntegration::ShortcutLocations result =
 195         ShellIntegrationLinux::GetExistingShortcutLocations(
 196             &env, kProfilePath, kExtensionId, desktop_path);
 197     EXPECT_TRUE(result.on_desktop);
 198     EXPECT_FALSE(result.in_applications_menu);
 199     EXPECT_FALSE(result.in_quick_launch_bar);
 200     EXPECT_FALSE(result.hidden);
 201   }
 202
 203   // Shortcut in applications directory.
 204   {
 205     base::ScopedTempDir temp_dir;
 206     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 207     base::FilePath apps_path = temp_dir.path().AppendASCII("applications");
 208
 209     MockEnvironment env;
 210     env.Set("XDG_DATA_HOME", temp_dir.path().value());
 211     ASSERT_TRUE(file_util::CreateDirectory(apps_path));
 212     ASSERT_FALSE(file_util::WriteFile(
 213         apps_path.AppendASCII(kTemplateFilename),
 214         "", 0));
 215     ShellIntegration::ShortcutLocations result =
 216         ShellIntegrationLinux::GetExistingShortcutLocations(
 217             &env, kProfilePath, kExtensionId);
 218     EXPECT_FALSE(result.on_desktop);
 219     EXPECT_TRUE(result.in_applications_menu);
 220     EXPECT_FALSE(result.in_quick_launch_bar);
 221     EXPECT_FALSE(result.hidden);
 222   }
 223
 224   // Shortcut in applications directory with NoDisplay=true.
 225   {
 226     base::ScopedTempDir temp_dir;
 227     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 228     base::FilePath apps_path = temp_dir.path().AppendASCII("applications");
 229
 230     MockEnvironment env;
 231     env.Set("XDG_DATA_HOME", temp_dir.path().value());
 232     ASSERT_TRUE(file_util::CreateDirectory(apps_path));
 233     ASSERT_TRUE(file_util::WriteFile(
 234         apps_path.AppendASCII(kTemplateFilename),
 235         kNoDisplayDesktopFile, strlen(kNoDisplayDesktopFile)));
 236     ShellIntegration::ShortcutLocations result =
 237         ShellIntegrationLinux::GetExistingShortcutLocations(
 238             &env, kProfilePath, kExtensionId);
 239     // Doesn't count as being in applications menu.
 240     EXPECT_FALSE(result.on_desktop);
 241     EXPECT_FALSE(result.in_applications_menu);
 242     EXPECT_FALSE(result.in_quick_launch_bar);
 243     EXPECT_TRUE(result.hidden);
 244   }
 245
 246   // Shortcut on desktop and in applications directory.
 247   {
 248     base::ScopedTempDir temp_dir1;
 249     ASSERT_TRUE(temp_dir1.CreateUniqueTempDir());
 250     base::FilePath desktop_path = temp_dir1.path();
 251
 252     base::ScopedTempDir temp_dir2;
 253     ASSERT_TRUE(temp_dir2.CreateUniqueTempDir());
 254     base::FilePath apps_path = temp_dir2.path().AppendASCII("applications");
 255
 256     MockEnvironment env;
 257     ASSERT_TRUE(file_util::CreateDirectory(desktop_path));
 258     ASSERT_FALSE(file_util::WriteFile(
 259         desktop_path.AppendASCII(kTemplateFilename),
 260         "", 0));
 261     env.Set("XDG_DATA_HOME", temp_dir2.path().value());
 262     ASSERT_TRUE(file_util::CreateDirectory(apps_path));
 263     ASSERT_FALSE(file_util::WriteFile(
 264         apps_path.AppendASCII(kTemplateFilename),
 265         "", 0));
 266     ShellIntegration::ShortcutLocations result =
 267         ShellIntegrationLinux::GetExistingShortcutLocations(
 268             &env, kProfilePath, kExtensionId, desktop_path);
 269     EXPECT_TRUE(result.on_desktop);
 270     EXPECT_TRUE(result.in_applications_menu);
 271     EXPECT_FALSE(result.in_quick_launch_bar);
 272     EXPECT_FALSE(result.hidden);
 273   }
 274 }
 275
 276 TEST(ShellIntegrationTest, GetExistingShortcutContents) {
 277   const char kTemplateFilename[] = "shortcut-test.desktop";
 278   base::FilePath kTemplateFilepath(kTemplateFilename);
 279   const char kTestData1[] = "a magical testing string";
 280   const char kTestData2[] = "a different testing string";
 281
 282   base::MessageLoop message_loop;
 283   content::TestBrowserThread file_thread(BrowserThread::FILE, &message_loop);
 284
 285   // Test that it searches $XDG_DATA_HOME/applications.
 286   {
 287     base::ScopedTempDir temp_dir;
 288     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 289
 290     MockEnvironment env;
 291     env.Set("XDG_DATA_HOME", temp_dir.path().value());
 292     // Create a file in a non-applications directory. This should be ignored.
 293     ASSERT_TRUE(file_util::WriteFile(
 294         temp_dir.path().AppendASCII(kTemplateFilename),
 295         kTestData2, strlen(kTestData2)));
 296     ASSERT_TRUE(file_util::CreateDirectory(
 297         temp_dir.path().AppendASCII("applications")));
 298     ASSERT_TRUE(file_util::WriteFile(
 299         temp_dir.path().AppendASCII("applications")
 300             .AppendASCII(kTemplateFilename),
 301         kTestData1, strlen(kTestData1)));
 302     std::string contents;
 303     ASSERT_TRUE(
 304         ShellIntegrationLinux::GetExistingShortcutContents(
 305             &env, kTemplateFilepath, &contents));
 306     EXPECT_EQ(kTestData1, contents);
 307   }
 308
 309   // Test that it falls back to $HOME/.local/share/applications.
 310   {
 311     base::ScopedTempDir temp_dir;
 312     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 313
 314     MockEnvironment env;
 315     env.Set("HOME", temp_dir.path().value());
 316     ASSERT_TRUE(file_util::CreateDirectory(
 317         temp_dir.path().AppendASCII(".local/share/applications")));
 318     ASSERT_TRUE(file_util::WriteFile(
 319         temp_dir.path().AppendASCII(".local/share/applications")
 320             .AppendASCII(kTemplateFilename),
 321         kTestData1, strlen(kTestData1)));
 322     std::string contents;
 323     ASSERT_TRUE(
 324         ShellIntegrationLinux::GetExistingShortcutContents(
 325             &env, kTemplateFilepath, &contents));
 326     EXPECT_EQ(kTestData1, contents);
 327   }
 328
 329   // Test that it searches $XDG_DATA_DIRS/applications.
 330   {
 331     base::ScopedTempDir temp_dir;
 332     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 333
 334     MockEnvironment env;
 335     env.Set("XDG_DATA_DIRS", temp_dir.path().value());
 336     ASSERT_TRUE(file_util::CreateDirectory(
 337         temp_dir.path().AppendASCII("applications")));
 338     ASSERT_TRUE(file_util::WriteFile(
 339         temp_dir.path().AppendASCII("applications")
 340             .AppendASCII(kTemplateFilename),
 341         kTestData2, strlen(kTestData2)));
 342     std::string contents;
 343     ASSERT_TRUE(
 344         ShellIntegrationLinux::GetExistingShortcutContents(
 345             &env, kTemplateFilepath, &contents));
 346     EXPECT_EQ(kTestData2, contents);
 347   }
 348
 349   // Test that it searches $X/applications for each X in $XDG_DATA_DIRS.
 350   {
 351     base::ScopedTempDir temp_dir1;
 352     ASSERT_TRUE(temp_dir1.CreateUniqueTempDir());
 353     base::ScopedTempDir temp_dir2;
 354     ASSERT_TRUE(temp_dir2.CreateUniqueTempDir());
 355
 356     MockEnvironment env;
 357     env.Set("XDG_DATA_DIRS", temp_dir1.path().value() + ":" +
 358                              temp_dir2.path().value());
 359     // Create a file in a non-applications directory. This should be ignored.
 360     ASSERT_TRUE(file_util::WriteFile(
 361         temp_dir1.path().AppendASCII(kTemplateFilename),
 362         kTestData1, strlen(kTestData1)));
 363     // Only create a findable desktop file in the second path.
 364     ASSERT_TRUE(file_util::CreateDirectory(
 365         temp_dir2.path().AppendASCII("applications")));
 366     ASSERT_TRUE(file_util::WriteFile(
 367         temp_dir2.path().AppendASCII("applications")
 368             .AppendASCII(kTemplateFilename),
 369         kTestData2, strlen(kTestData2)));
 370     std::string contents;
 371     ASSERT_TRUE(
 372         ShellIntegrationLinux::GetExistingShortcutContents(
 373             &env, kTemplateFilepath, &contents));
 374     EXPECT_EQ(kTestData2, contents);
 375   }
 376 }
 377
 378 TEST(ShellIntegrationTest, GetExtensionShortcutFilename) {
 379   base::FilePath kProfilePath("a/b/c/Profile Name?");
 380   const char kExtensionId[] = "extensionid";
 381   EXPECT_EQ(base::FilePath("chrome-extensionid-Profile_Name_.desktop"),
 382             ShellIntegrationLinux::GetExtensionShortcutFilename(
 383                 kProfilePath, kExtensionId));
 384 }
 385
 386 TEST(ShellIntegrationTest, GetExistingProfileShortcutFilenames) {
 387   base::FilePath kProfilePath("a/b/c/Profile Name?");
 388   const char kApp1Filename[] = "chrome-extension1-Profile_Name_.desktop";
 389   const char kApp2Filename[] = "chrome-extension2-Profile_Name_.desktop";
 390   const char kUnrelatedAppFilename[] = "chrome-extension-Other_Profile.desktop";
 391
 392   base::MessageLoop message_loop;
 393   content::TestBrowserThread file_thread(BrowserThread::FILE, &message_loop);
 394
 395   base::ScopedTempDir temp_dir;
 396   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 397   ASSERT_EQ(0,
 398             file_util::WriteFile(
 399                 temp_dir.path().AppendASCII(kApp1Filename), "", 0));
 400   ASSERT_EQ(0,
 401             file_util::WriteFile(
 402                 temp_dir.path().AppendASCII(kApp2Filename), "", 0));
 403   // This file should not be returned in the results.
 404   ASSERT_EQ(0,
 405             file_util::WriteFile(
 406                 temp_dir.path().AppendASCII(kUnrelatedAppFilename), "", 0));
 407   std::vector<base::FilePath> paths =
 408       ShellIntegrationLinux::GetExistingProfileShortcutFilenames(
 409           kProfilePath, temp_dir.path());
 410   // Path order is arbitrary. Sort the output for consistency.
 411   std::sort(paths.begin(), paths.end());
 412   EXPECT_THAT(paths,
 413               ElementsAre(base::FilePath(kApp1Filename),
 414                           base::FilePath(kApp2Filename)));
 415 }
 416
 417 TEST(ShellIntegrationTest, GetWebShortcutFilename) {
 418   const struct {
 419     const base::FilePath::CharType* path;
 420     const char* url;
 421   } test_cases[] = {
 422     { FPL("http___foo_.desktop"), "http://foo" },
 423     { FPL("http___foo_bar_.desktop"), "http://foo/bar/" },
 424     { FPL("http___foo_bar_a=b&c=d.desktop"), "http://foo/bar?a=b&c=d" },
 425
 426     // Now we're starting to be more evil...
 427     { FPL("http___foo_.desktop"), "http://foo/bar/baz/../../../../../" },
 428     { FPL("http___foo_.desktop"), "http://foo/bar/././../baz/././../" },
 429     { FPL("http___.._.desktop"), "http://../../../../" },
 430   };
 431   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); i++) {
 432     EXPECT_EQ(std::string(chrome::kBrowserProcessExecutableName) + "-" +
 433               test_cases[i].path,
 434               ShellIntegrationLinux::GetWebShortcutFilename(
 435                   GURL(test_cases[i].url)).value()) <<
 436         " while testing " << test_cases[i].url;
 437   }
 438 }
 439
 440 TEST(ShellIntegrationTest, GetDesktopFileContents) {
 441   const base::FilePath kChromeExePath("/opt/google/chrome/google-chrome");
 442   const struct {
 443     const char* url;
 444     const char* title;
 445     const char* icon_name;
 446     bool nodisplay;
 447     const char* expected_output;
 448   } test_cases[] = {
 449     // Real-world case.
 450     { "http://gmail.com",
 451       "GMail",
 452       "chrome-http__gmail.com",
 453       false,
 454
 455       "#!/usr/bin/env xdg-open\n"
 456       "[Desktop Entry]\n"
 457       "Version=1.0\n"
 458       "Terminal=false\n"
 459       "Type=Application\n"
 460       "Name=GMail\n"
 461       "Exec=/opt/google/chrome/google-chrome --app=http://gmail.com/\n"
 462       "Icon=chrome-http__gmail.com\n"
 463 #if !defined(USE_AURA)
 464       // Aura Chrome does not (yet) set WMClass, so we only expect
 465       // StartupWMClass on non-Aura builds.
 466       "StartupWMClass=gmail.com\n"
 467 #endif
 468     },
 469
 470     // Make sure that empty icons are replaced by the chrome icon.
 471     { "http://gmail.com",
 472       "GMail",
 473       "",
 474       false,
 475
 476       "#!/usr/bin/env xdg-open\n"
 477       "[Desktop Entry]\n"
 478       "Version=1.0\n"
 479       "Terminal=false\n"
 480       "Type=Application\n"
 481       "Name=GMail\n"
 482       "Exec=/opt/google/chrome/google-chrome --app=http://gmail.com/\n"
 483       "Icon=chromium-browser\n"
 484 #if !defined(USE_AURA)
 485       // Aura Chrome does not (yet) set WMClass, so we only expect
 486       // StartupWMClass on non-Aura builds.
 487       "StartupWMClass=gmail.com\n"
 488 #endif
 489     },
 490
 491     // Test adding NoDisplay=true.
 492     { "http://gmail.com",
 493       "GMail",
 494       "chrome-http__gmail.com",
 495       true,
 496
 497       "#!/usr/bin/env xdg-open\n"
 498       "[Desktop Entry]\n"
 499       "Version=1.0\n"
 500       "Terminal=false\n"
 501       "Type=Application\n"
 502       "Name=GMail\n"
 503       "Exec=/opt/google/chrome/google-chrome --app=http://gmail.com/\n"
 504       "Icon=chrome-http__gmail.com\n"
 505       "NoDisplay=true\n"
 506 #if !defined(USE_AURA)
 507       // Aura Chrome does not (yet) set WMClass, so we only expect
 508       // StartupWMClass on non-Aura builds.
 509       "StartupWMClass=gmail.com\n"
 510 #endif
 511     },
 512
 513     // Now we're starting to be more evil...
 514     { "http://evil.com/evil --join-the-b0tnet",
 515       "Ownz0red\nExec=rm -rf /",
 516       "chrome-http__evil.com_evil",
 517       false,
 518
 519       "#!/usr/bin/env xdg-open\n"
 520       "[Desktop Entry]\n"
 521       "Version=1.0\n"
 522       "Terminal=false\n"
 523       "Type=Application\n"
 524       "Name=http://evil.com/evil%20--join-the-b0tnet\n"
 525       "Exec=/opt/google/chrome/google-chrome "
 526       "--app=http://evil.com/evil%20--join-the-b0tnet\n"
 527       "Icon=chrome-http__evil.com_evil\n"
 528 #if !defined(USE_AURA)
 529       // Aura Chrome does not (yet) set WMClass, so we only expect
 530       // StartupWMClass on non-Aura builds.
 531       "StartupWMClass=evil.com__evil%20--join-the-b0tnet\n"
 532 #endif
 533     },
 534     { "http://evil.com/evil; rm -rf /; \"; rm -rf $HOME >ownz0red",
 535       "Innocent Title",
 536       "chrome-http__evil.com_evil",
 537       false,
 538
 539       "#!/usr/bin/env xdg-open\n"
 540       "[Desktop Entry]\n"
 541       "Version=1.0\n"
 542       "Terminal=false\n"
 543       "Type=Application\n"
 544       "Name=Innocent Title\n"
 545       "Exec=/opt/google/chrome/google-chrome "
 546       "\"--app=http://evil.com/evil;%20rm%20-rf%20/;%20%22;%20rm%20"
 547       // Note: $ is escaped as \$ within an arg to Exec, and then
 548       // the \ is escaped as \\ as all strings in a Desktop file should
 549       // be; finally, \\ becomes \\\\ when represented in a C++ string!
 550       "-rf%20\\\\$HOME%20%3Eownz0red\"\n"
 551       "Icon=chrome-http__evil.com_evil\n"
 552 #if !defined(USE_AURA)
 553       // Aura Chrome does not (yet) set WMClass, so we only expect
 554       // StartupWMClass on non-Aura builds.
 555       "StartupWMClass=evil.com__evil;%20rm%20-rf%20_;%20%22;%20"
 556       "rm%20-rf%20$HOME%20%3Eownz0red\n"
 557 #endif
 558     },
 559     { "http://evil.com/evil | cat `echo ownz0red` >/dev/null",
 560       "Innocent Title",
 561       "chrome-http__evil.com_evil",
 562       false,
 563
 564       "#!/usr/bin/env xdg-open\n"
 565       "[Desktop Entry]\n"
 566       "Version=1.0\n"
 567       "Terminal=false\n"
 568       "Type=Application\n"
 569       "Name=Innocent Title\n"
 570       "Exec=/opt/google/chrome/google-chrome "
 571       "--app=http://evil.com/evil%20%7C%20cat%20%60echo%20ownz0red"
 572       "%60%20%3E/dev/null\n"
 573       "Icon=chrome-http__evil.com_evil\n"
 574 #if !defined(USE_AURA)
 575       // Aura Chrome does not (yet) set WMClass, so we only expect
 576       // StartupWMClass on non-Aura builds.
 577       "StartupWMClass=evil.com__evil%20%7C%20cat%20%60echo%20ownz0red"
 578       "%60%20%3E_dev_null\n"
 579 #endif
 580     },
 581   };
 582
 583   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); i++) {
 584     SCOPED_TRACE(i);
 585     EXPECT_EQ(
 586         test_cases[i].expected_output,
 587         ShellIntegrationLinux::GetDesktopFileContents(
 588             kChromeExePath,
 589             web_app::GenerateApplicationNameFromURL(GURL(test_cases[i].url)),
 590             GURL(test_cases[i].url),
 591             std::string(),
 592             base::FilePath(),
 593             ASCIIToUTF16(test_cases[i].title),
 594             test_cases[i].icon_name,
 595             base::FilePath(),
 596             test_cases[i].nodisplay));
 597   }
 598 }
 599
 600 TEST(ShellIntegrationTest, GetDirectoryFileContents) {
 601   const struct {
 602     const char* title;
 603     const char* icon_name;
 604     const char* expected_output;
 605   } test_cases[] = {
 606     // Real-world case.
 607     { "Chrome Apps",
 608       "chrome-apps",
 609
 610       "[Desktop Entry]\n"
 611       "Version=1.0\n"
 612       "Type=Directory\n"
 613       "Name=Chrome Apps\n"
 614       "Icon=chrome-apps\n"
 615     },
 616
 617     // Make sure that empty icons are replaced by the chrome icon.
 618     { "Chrome Apps",
 619       "",
 620
 621       "[Desktop Entry]\n"
 622       "Version=1.0\n"
 623       "Type=Directory\n"
 624       "Name=Chrome Apps\n"
 625       "Icon=chromium-browser\n"
 626     },
 627   };
 628
 629   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); i++) {
 630     SCOPED_TRACE(i);
 631     EXPECT_EQ(
 632         test_cases[i].expected_output,
 633         ShellIntegrationLinux::GetDirectoryFileContents(
 634             ASCIIToUTF16(test_cases[i].title),
 635             test_cases[i].icon_name));
 636   }
 637 }
 638
 639 #endif