| OLD | NEW |
| (Empty) |
| 1 // Copyright 2013 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 "apps/app_shim/app_shim_host_manager_mac.h" | |
| 6 | |
| 7 #include <unistd.h> | |
| 8 | |
| 9 #include "apps/app_shim/app_shim_handler_mac.h" | |
| 10 #include "apps/app_shim/app_shim_host_mac.h" | |
| 11 #include "base/base64.h" | |
| 12 #include "base/bind.h" | |
| 13 #include "base/command_line.h" | |
| 14 #include "base/files/file_path.h" | |
| 15 #include "base/files/file_util.h" | |
| 16 #include "base/logging.h" | |
| 17 #include "base/path_service.h" | |
| 18 #include "base/sha1.h" | |
| 19 #include "base/strings/string_util.h" | |
| 20 #include "chrome/browser/browser_process.h" | |
| 21 #include "chrome/common/chrome_paths.h" | |
| 22 #include "chrome/common/chrome_switches.h" | |
| 23 #include "chrome/common/chrome_version_info.h" | |
| 24 #include "chrome/common/mac/app_mode_common.h" | |
| 25 | |
| 26 using content::BrowserThread; | |
| 27 | |
| 28 namespace { | |
| 29 | |
| 30 void CreateAppShimHost(const IPC::ChannelHandle& handle) { | |
| 31 // AppShimHost takes ownership of itself. | |
| 32 (new AppShimHost)->ServeChannel(handle); | |
| 33 } | |
| 34 | |
| 35 base::FilePath GetDirectoryInTmpTemplate(const base::FilePath& user_data_dir) { | |
| 36 base::FilePath temp_dir; | |
| 37 CHECK(PathService::Get(base::DIR_TEMP, &temp_dir)); | |
| 38 // Check that it's shorter than the IPC socket length (104) minus the | |
| 39 // intermediate folder ("/chrome-XXXXXX/") and kAppShimSocketShortName. | |
| 40 DCHECK_GT(83u, temp_dir.value().length()); | |
| 41 return temp_dir.Append("chrome-XXXXXX"); | |
| 42 } | |
| 43 | |
| 44 void DeleteSocketFiles(const base::FilePath& directory_in_tmp, | |
| 45 const base::FilePath& symlink_path, | |
| 46 const base::FilePath& version_path) { | |
| 47 // Delete in reverse order of creation. | |
| 48 if (!version_path.empty()) | |
| 49 base::DeleteFile(version_path, false); | |
| 50 if (!symlink_path.empty()) | |
| 51 base::DeleteFile(symlink_path, false); | |
| 52 if (!directory_in_tmp.empty()) | |
| 53 base::DeleteFile(directory_in_tmp, true); | |
| 54 } | |
| 55 | |
| 56 } // namespace | |
| 57 | |
| 58 AppShimHostManager::AppShimHostManager() | |
| 59 : did_init_(false) {} | |
| 60 | |
| 61 void AppShimHostManager::Init() { | |
| 62 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 63 DCHECK(!did_init_); | |
| 64 did_init_ = true; | |
| 65 apps::AppShimHandler::SetDefaultHandler(&extension_app_shim_handler_); | |
| 66 BrowserThread::PostTask( | |
| 67 BrowserThread::FILE, FROM_HERE, | |
| 68 base::Bind(&AppShimHostManager::InitOnFileThread, this)); | |
| 69 } | |
| 70 | |
| 71 AppShimHostManager::~AppShimHostManager() { | |
| 72 acceptor_.reset(); | |
| 73 if (!did_init_) | |
| 74 return; | |
| 75 | |
| 76 apps::AppShimHandler::SetDefaultHandler(NULL); | |
| 77 base::FilePath user_data_dir; | |
| 78 base::FilePath symlink_path; | |
| 79 base::FilePath version_path; | |
| 80 if (PathService::Get(chrome::DIR_USER_DATA, &user_data_dir)) { | |
| 81 symlink_path = user_data_dir.Append(app_mode::kAppShimSocketSymlinkName); | |
| 82 version_path = | |
| 83 user_data_dir.Append(app_mode::kRunningChromeVersionSymlinkName); | |
| 84 } | |
| 85 BrowserThread::PostTask( | |
| 86 BrowserThread::FILE, | |
| 87 FROM_HERE, | |
| 88 base::Bind( | |
| 89 &DeleteSocketFiles, directory_in_tmp_, symlink_path, version_path)); | |
| 90 } | |
| 91 | |
| 92 void AppShimHostManager::InitOnFileThread() { | |
| 93 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); | |
| 94 base::FilePath user_data_dir; | |
| 95 if (!PathService::Get(chrome::DIR_USER_DATA, &user_data_dir)) | |
| 96 return; | |
| 97 | |
| 98 // The socket path must be shorter than 104 chars (IPC::kMaxSocketNameLength). | |
| 99 // To accommodate this, we use a short path in /tmp/ that is generated from a | |
| 100 // hash of the user data dir. | |
| 101 std::string directory_string = | |
| 102 GetDirectoryInTmpTemplate(user_data_dir).value(); | |
| 103 | |
| 104 // mkdtemp() replaces trailing X's randomly and creates the directory. | |
| 105 if (!mkdtemp(&directory_string[0])) { | |
| 106 PLOG(ERROR) << directory_string; | |
| 107 return; | |
| 108 } | |
| 109 | |
| 110 directory_in_tmp_ = base::FilePath(directory_string); | |
| 111 // Check that the directory was created with the correct permissions. | |
| 112 int dir_mode = 0; | |
| 113 if (!base::GetPosixFilePermissions(directory_in_tmp_, &dir_mode) || | |
| 114 dir_mode != base::FILE_PERMISSION_USER_MASK) { | |
| 115 NOTREACHED(); | |
| 116 return; | |
| 117 } | |
| 118 | |
| 119 // UnixDomainSocketAcceptor creates the socket immediately. | |
| 120 base::FilePath socket_path = | |
| 121 directory_in_tmp_.Append(app_mode::kAppShimSocketShortName); | |
| 122 acceptor_.reset(new apps::UnixDomainSocketAcceptor(socket_path, this)); | |
| 123 | |
| 124 // Create a symlink to the socket in the user data dir. This lets the shim | |
| 125 // process started from Finder find the actual socket path by following the | |
| 126 // symlink with ::readlink(). | |
| 127 base::FilePath symlink_path = | |
| 128 user_data_dir.Append(app_mode::kAppShimSocketSymlinkName); | |
| 129 base::DeleteFile(symlink_path, false); | |
| 130 base::CreateSymbolicLink(socket_path, symlink_path); | |
| 131 | |
| 132 // Create a symlink containing the current version string. This allows the | |
| 133 // shim to load the same framework version as the currently running Chrome | |
| 134 // process. | |
| 135 base::FilePath version_path = | |
| 136 user_data_dir.Append(app_mode::kRunningChromeVersionSymlinkName); | |
| 137 base::DeleteFile(version_path, false); | |
| 138 base::CreateSymbolicLink(base::FilePath(chrome::VersionInfo().Version()), | |
| 139 version_path); | |
| 140 | |
| 141 BrowserThread::PostTask( | |
| 142 BrowserThread::IO, FROM_HERE, | |
| 143 base::Bind(&AppShimHostManager::ListenOnIOThread, this)); | |
| 144 } | |
| 145 | |
| 146 void AppShimHostManager::ListenOnIOThread() { | |
| 147 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 148 if (!acceptor_->Listen()) { | |
| 149 BrowserThread::PostTask( | |
| 150 BrowserThread::UI, FROM_HERE, | |
| 151 base::Bind(&AppShimHostManager::OnListenError, this)); | |
| 152 } | |
| 153 } | |
| 154 | |
| 155 void AppShimHostManager::OnClientConnected( | |
| 156 const IPC::ChannelHandle& handle) { | |
| 157 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 158 BrowserThread::PostTask( | |
| 159 BrowserThread::UI, FROM_HERE, | |
| 160 base::Bind(&CreateAppShimHost, handle)); | |
| 161 } | |
| 162 | |
| 163 void AppShimHostManager::OnListenError() { | |
| 164 // TODO(tapted): Set a timeout and attempt to reconstruct the channel. Until | |
| 165 // cases where the error could occur are better known, just reset the acceptor | |
| 166 // to allow failure to be communicated via the test API. | |
| 167 acceptor_.reset(); | |
| 168 } | |
| OLD | NEW |