Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 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 | // chrome_tab.cc : Implementation of DLL Exports. |
| 6 | |
| 7 | // Need to include this before the ATL headers below. |
| 8 | #include "chrome_frame/chrome_tab.h" |
| 9 | |
| 10 | #include <atlsecurity.h> |
| 11 | #include <objbase.h> |
| 12 | |
| 13 | #include "base/at_exit.h" |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 14 | #include "base/basictypes.h" |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 15 | #include "base/command_line.h" |
| 16 | #include "base/file_util.h" |
| 17 | #include "base/file_version_info.h" |
| 18 | #include "base/logging.h" |
| 19 | #include "base/logging_win.h" |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 20 | #include "base/path_service.h" |
Ben Murdoch | a3f7b4e | 2013-07-24 10:36:34 +0100 | [diff] [blame] | 21 | #include "base/process/launch.h" |
Torne (Richard Coles) | 868fa2f | 2013-06-11 10:57:03 +0100 | [diff] [blame] | 22 | #include "base/strings/string16.h" |
| 23 | #include "base/strings/string_number_conversions.h" |
Torne (Richard Coles) | c2e0dbd | 2013-05-09 18:35:53 +0100 | [diff] [blame] | 24 | #include "base/strings/string_piece.h" |
Torne (Richard Coles) | 868fa2f | 2013-06-11 10:57:03 +0100 | [diff] [blame] | 25 | #include "base/strings/string_util.h" |
Torne (Richard Coles) | c2e0dbd | 2013-05-09 18:35:53 +0100 | [diff] [blame] | 26 | #include "base/strings/sys_string_conversions.h" |
Torne (Richard Coles) | 868fa2f | 2013-06-11 10:57:03 +0100 | [diff] [blame] | 27 | #include "base/strings/utf_string_conversions.h" |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 28 | #include "base/win/registry.h" |
| 29 | #include "base/win/windows_version.h" |
| 30 | #include "chrome/common/chrome_constants.h" |
| 31 | #include "chrome/common/chrome_switches.h" |
| 32 | #include "chrome/common/metrics/entropy_provider.h" |
| 33 | #include "chrome/installer/util/google_update_settings.h" |
| 34 | #include "chrome_frame/bho.h" |
| 35 | #include "chrome_frame/chrome_active_document.h" |
| 36 | #include "chrome_frame/chrome_frame_activex.h" |
| 37 | #include "chrome_frame/chrome_frame_automation.h" |
| 38 | #include "chrome_frame/chrome_frame_reporting.h" |
| 39 | #include "chrome_frame/chrome_launcher_utils.h" |
| 40 | #include "chrome_frame/chrome_protocol.h" |
| 41 | #include "chrome_frame/dll_redirector.h" |
| 42 | #include "chrome_frame/exception_barrier.h" |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 43 | #include "chrome_frame/pin_module.h" |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 44 | #include "chrome_frame/resource.h" |
| 45 | #include "chrome_frame/utils.h" |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 46 | #include "grit/chrome_frame_resources.h" |
Ben Murdoch | 7dbb3d5 | 2013-07-17 14:55:54 +0100 | [diff] [blame] | 47 | #include "url/url_util.h" |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 48 | |
| 49 | using base::win::RegKey; |
| 50 | |
| 51 | namespace { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 52 | |
| 53 | const wchar_t kInternetSettings[] = |
| 54 | L"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings"; |
| 55 | |
| 56 | const wchar_t kProtocolHandlers[] = |
| 57 | L"Software\\Classes\\Protocols\\Handler"; |
| 58 | |
| 59 | const wchar_t kRunOnce[] = |
| 60 | L"Software\\Microsoft\\Windows\\CurrentVersion\\RunOnce"; |
| 61 | |
| 62 | const wchar_t kRunKeyName[] = L"ChromeFrameHelper"; |
| 63 | |
| 64 | const wchar_t kChromeFrameHelperExe[] = L"chrome_frame_helper.exe"; |
| 65 | const wchar_t kChromeFrameHelperStartupArg[] = L"--startup"; |
| 66 | |
| 67 | // Window class and window names. |
| 68 | // TODO(robertshield): These and other constants need to be refactored into |
| 69 | // a common chrome_frame_constants.h|cc and built into a separate lib |
| 70 | // (either chrome_frame_utils or make another one). |
| 71 | const wchar_t kChromeFrameHelperWindowClassName[] = |
| 72 | L"ChromeFrameHelperWindowClass"; |
| 73 | const wchar_t kChromeFrameHelperWindowName[] = |
| 74 | L"ChromeFrameHelperWindowName"; |
| 75 | |
| 76 | // {0562BFC3-2550-45b4-BD8E-A310583D3A6F} |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 77 | const GUID kChromeFrameProvider = |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 78 | { 0x562bfc3, 0x2550, 0x45b4, |
| 79 | { 0xbd, 0x8e, 0xa3, 0x10, 0x58, 0x3d, 0x3a, 0x6f } }; |
| 80 | |
| 81 | const wchar_t kPostPlatformUAKey[] = |
| 82 | L"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\" |
| 83 | L"User Agent\\Post Platform"; |
| 84 | const wchar_t kChromeFramePrefix[] = L"chromeframe/"; |
| 85 | |
| 86 | // See comments in DllGetClassObject. |
| 87 | LPFNGETCLASSOBJECT g_dll_get_class_object_redir_ptr = NULL; |
| 88 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 89 | // This function has the side effect of initializing an unprotected |
| 90 | // vector pointer inside GoogleUrl. If this is called during DLL loading, |
| 91 | // it has the effect of avoiding an initialization race on that pointer. |
| 92 | // TODO(siggi): fix GoogleUrl. |
| 93 | void InitGoogleUrl() { |
| 94 | static const char kDummyUrl[] = "http://www.google.com"; |
| 95 | |
| 96 | url_util::IsStandard(kDummyUrl, |
| 97 | url_parse::MakeRange(0, arraysize(kDummyUrl))); |
| 98 | } |
| 99 | |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 100 | class ChromeTabModule : public CAtlDllModuleT<ChromeTabModule> { |
| 101 | public: |
| 102 | typedef CAtlDllModuleT<ChromeTabModule> ParentClass; |
| 103 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 104 | ChromeTabModule() : do_system_registration_(true), crash_reporting_(NULL) {} |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 105 | |
| 106 | DECLARE_LIBID(LIBID_ChromeTabLib) |
| 107 | DECLARE_REGISTRY_APPID_RESOURCEID(IDR_CHROMETAB, |
| 108 | "{FD9B1B31-F4D8-436A-8F4F-D3C2E36733D3}") |
| 109 | |
| 110 | // Override to add our SYSTIME binary value to registry scripts. |
| 111 | // See chrome_frame_activex.rgs for usage. |
| 112 | virtual HRESULT AddCommonRGSReplacements(IRegistrarBase* registrar) throw() { |
| 113 | HRESULT hr = ParentClass::AddCommonRGSReplacements(registrar); |
| 114 | |
| 115 | if (SUCCEEDED(hr)) { |
| 116 | SYSTEMTIME local_time; |
| 117 | ::GetSystemTime(&local_time); |
| 118 | std::string hex(base::HexEncode(&local_time, sizeof(local_time))); |
| 119 | base::StringPiece sp_hex(hex); |
| 120 | hr = registrar->AddReplacement(L"SYSTIME", |
| 121 | base::SysNativeMBToWide(sp_hex).c_str()); |
| 122 | DCHECK(SUCCEEDED(hr)); |
| 123 | } |
| 124 | |
| 125 | if (SUCCEEDED(hr)) { |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 126 | base::FilePath app_path = |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 127 | chrome_launcher::GetChromeExecutablePath().DirName(); |
| 128 | hr = registrar->AddReplacement(L"CHROME_APPPATH", |
| 129 | app_path.value().c_str()); |
| 130 | DCHECK(SUCCEEDED(hr)); |
| 131 | } |
| 132 | |
| 133 | if (SUCCEEDED(hr)) { |
| 134 | hr = registrar->AddReplacement(L"CHROME_APPNAME", |
| 135 | chrome::kBrowserProcessExecutableName); |
| 136 | DCHECK(SUCCEEDED(hr)); |
| 137 | |
| 138 | // Fill in VERSION from the VERSIONINFO stored in the DLL's resources. |
| 139 | scoped_ptr<FileVersionInfo> module_version_info( |
| 140 | FileVersionInfo::CreateFileVersionInfoForCurrentModule()); |
| 141 | DCHECK(module_version_info != NULL); |
| 142 | std::wstring file_version(module_version_info->file_version()); |
| 143 | hr = registrar->AddReplacement(L"VERSION", file_version.c_str()); |
| 144 | DCHECK(SUCCEEDED(hr)); |
| 145 | } |
| 146 | |
| 147 | if (SUCCEEDED(hr)) { |
| 148 | // Add the directory of chrome_launcher.exe. This will be the same |
| 149 | // as the directory for the current DLL. |
| 150 | std::wstring module_dir; |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 151 | base::FilePath module_path; |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 152 | if (PathService::Get(base::FILE_MODULE, &module_path)) { |
| 153 | module_dir = module_path.DirName().value(); |
| 154 | } else { |
| 155 | NOTREACHED(); |
| 156 | } |
| 157 | hr = registrar->AddReplacement(L"CHROME_LAUNCHER_APPPATH", |
| 158 | module_dir.c_str()); |
| 159 | DCHECK(SUCCEEDED(hr)); |
| 160 | } |
| 161 | |
| 162 | if (SUCCEEDED(hr)) { |
| 163 | // Add the filename of chrome_launcher.exe |
| 164 | hr = registrar->AddReplacement(L"CHROME_LAUNCHER_APPNAME", |
| 165 | chrome_launcher::kLauncherExeBaseName); |
| 166 | DCHECK(SUCCEEDED(hr)); |
| 167 | } |
| 168 | |
| 169 | if (SUCCEEDED(hr)) { |
| 170 | // Add the registry hive to use. |
| 171 | // Note: This is ugly as hell. I'd rather use the pMapEntries parameter |
| 172 | // to CAtlModule::UpdateRegistryFromResource, unfortunately we have a |
| 173 | // few components that are registered by calling their |
| 174 | // static T::UpdateRegistry() methods directly, which doesn't allow |
| 175 | // pMapEntries to be passed through :-( |
| 176 | if (do_system_registration_) { |
| 177 | hr = registrar->AddReplacement(L"HIVE", L"HKLM"); |
| 178 | } else { |
| 179 | hr = registrar->AddReplacement(L"HIVE", L"HKCU"); |
| 180 | } |
| 181 | DCHECK(SUCCEEDED(hr)); |
| 182 | } |
| 183 | |
| 184 | if (SUCCEEDED(hr)) { |
| 185 | // Add the Chrome Frame CLSID. |
| 186 | wchar_t cf_clsid[64]; |
| 187 | StringFromGUID2(CLSID_ChromeFrame, &cf_clsid[0], arraysize(cf_clsid)); |
| 188 | hr = registrar->AddReplacement(L"CHROME_FRAME_CLSID", &cf_clsid[0]); |
| 189 | } |
| 190 | |
| 191 | return hr; |
| 192 | } |
| 193 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 194 | // The module is "locked" when an object takes a reference on it. The first |
| 195 | // time it is locked, take a reference on crash reporting to bind its lifetime |
| 196 | // to the module. |
| 197 | virtual LONG Lock() throw() { |
| 198 | LONG result = ParentClass::Lock(); |
| 199 | if (result == 1) { |
| 200 | DCHECK_EQ(crash_reporting_, |
| 201 | static_cast<chrome_frame::ScopedCrashReporting*>(NULL)); |
| 202 | crash_reporting_ = new chrome_frame::ScopedCrashReporting(); |
| 203 | } |
| 204 | return result; |
| 205 | } |
| 206 | |
| 207 | // The module is "unlocked" when an object that had a reference on it is |
| 208 | // destroyed. The last time it is unlocked, release the reference on crash |
| 209 | // reporting. |
| 210 | virtual LONG Unlock() throw() { |
| 211 | LONG result = ParentClass::Unlock(); |
| 212 | if (!result) { |
| 213 | DCHECK_NE(crash_reporting_, |
| 214 | static_cast<chrome_frame::ScopedCrashReporting*>(NULL)); |
| 215 | delete crash_reporting_; |
| 216 | crash_reporting_ = NULL; |
| 217 | } |
| 218 | return result; |
| 219 | } |
| 220 | |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 221 | // See comments in AddCommonRGSReplacements |
| 222 | bool do_system_registration_; |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 223 | |
| 224 | private: |
| 225 | // A scoper created when the module is initially locked and destroyed when it |
| 226 | // is finally unlocked. This is not a scoped_ptr since that could cause |
| 227 | // reporting to shut down at exit, which would lead to problems with the |
| 228 | // loader lock. |
| 229 | chrome_frame::ScopedCrashReporting* crash_reporting_; |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 230 | }; |
| 231 | |
| 232 | ChromeTabModule _AtlModule; |
| 233 | |
| 234 | base::AtExitManager* g_exit_manager = NULL; |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 235 | |
| 236 | HRESULT RefreshElevationPolicy() { |
| 237 | const wchar_t kIEFrameDll[] = L"ieframe.dll"; |
| 238 | const char kIERefreshPolicy[] = "IERefreshElevationPolicy"; |
| 239 | HRESULT hr = E_NOTIMPL; |
| 240 | |
| 241 | // Stick an SEH in the chain to prevent the VEH from picking up on first |
| 242 | // chance exceptions caused by loading ieframe.dll. Use the vanilla |
| 243 | // ExceptionBarrier to report any exceptions that do make their way to us |
| 244 | // though. |
| 245 | ExceptionBarrier barrier; |
| 246 | |
| 247 | HMODULE ieframe_module = LoadLibrary(kIEFrameDll); |
| 248 | if (ieframe_module) { |
| 249 | typedef HRESULT (__stdcall *IERefreshPolicy)(); |
| 250 | IERefreshPolicy ie_refresh_policy = reinterpret_cast<IERefreshPolicy>( |
| 251 | GetProcAddress(ieframe_module, kIERefreshPolicy)); |
| 252 | |
| 253 | if (ie_refresh_policy) { |
| 254 | hr = ie_refresh_policy(); |
| 255 | } else { |
| 256 | hr = HRESULT_FROM_WIN32(GetLastError()); |
| 257 | } |
| 258 | |
| 259 | FreeLibrary(ieframe_module); |
| 260 | } else { |
| 261 | hr = HRESULT_FROM_WIN32(GetLastError()); |
| 262 | } |
| 263 | |
| 264 | return hr; |
| 265 | } |
| 266 | |
| 267 | // Experimental boot prefetch optimization for Chrome Frame |
| 268 | // |
| 269 | // If chrome is warmed up during a single reboot, it gets paged |
| 270 | // in for subsequent reboots and the cold startup times essentially |
| 271 | // look like warm times thereafter! The 'warm up' is done by |
| 272 | // setting up a 'RunOnce' key during DLLRegisterServer of |
| 273 | // npchrome_frame.dll. |
| 274 | // |
| 275 | // This works because chrome prefetch becomes part of boot |
| 276 | // prefetch file ntosboot-b00dfaad.pf and paged in on subsequent |
| 277 | // reboots. As long as the sytem does not undergo significant |
| 278 | // memory pressure those pages remain in memory and we get pretty |
| 279 | // amazing startup times, down to about 300 ms from 1200 ms |
| 280 | // |
| 281 | // The downside is: |
| 282 | // - Whether chrome frame is used or not, there's a read penalty |
| 283 | // (1200-300 =) 900 ms for every boot. |
| 284 | // - Heavy system memory usage after reboot will nullify the benefits |
| 285 | // but the user will still pay the cost. |
| 286 | // - Overall the time saved will always be less than total time spent |
| 287 | // paging in chrome |
| 288 | // - We are not sure when the chrome 'warm up' will age out from the |
| 289 | // boot prefetch file. |
| 290 | // |
| 291 | // The idea here is to try this out on chrome frame dev channel |
| 292 | // and see if it produces a significant drift in startup numbers. |
| 293 | HRESULT SetupRunOnce() { |
| 294 | HRESULT result = E_FAIL; |
| 295 | |
| 296 | string16 channel_name; |
| 297 | if (base::win::GetVersion() < base::win::VERSION_VISTA && |
| 298 | GoogleUpdateSettings::GetChromeChannelAndModifiers(true, &channel_name)) { |
| 299 | std::transform(channel_name.begin(), channel_name.end(), |
| 300 | channel_name.begin(), tolower); |
| 301 | // Use this only for the dev channel. |
| 302 | if (channel_name.find(L"dev") != string16::npos) { |
| 303 | HKEY hive = HKEY_CURRENT_USER; |
| 304 | if (IsSystemProcess()) { |
| 305 | // For system installs, our updates will be running as SYSTEM which |
| 306 | // makes writing to a RunOnce key under HKCU not so terribly useful. |
| 307 | hive = HKEY_LOCAL_MACHINE; |
| 308 | } |
| 309 | |
| 310 | RegKey run_once; |
| 311 | LONG ret = run_once.Create(hive, kRunOnce, KEY_READ | KEY_WRITE); |
| 312 | if (ret == ERROR_SUCCESS) { |
| 313 | CommandLine run_once_cmd(chrome_launcher::GetChromeExecutablePath()); |
| 314 | run_once_cmd.AppendSwitchASCII(switches::kAutomationClientChannelID, |
| 315 | "0"); |
| 316 | run_once_cmd.AppendSwitch(switches::kChromeFrame); |
| 317 | ret = run_once.WriteValue(L"A", |
| 318 | run_once_cmd.GetCommandLineString().c_str()); |
| 319 | } |
| 320 | result = HRESULT_FROM_WIN32(ret); |
| 321 | } else { |
| 322 | result = S_FALSE; |
| 323 | } |
| 324 | } else { |
| 325 | // We're on a non-XP version of Windows or on a stable channel. Nothing |
| 326 | // needs doing. |
| 327 | result = S_FALSE; |
| 328 | } |
| 329 | |
| 330 | return result; |
| 331 | } |
| 332 | |
| 333 | // Helper method called for user-level installs where we don't have admin |
| 334 | // permissions. Starts up the long running process and registers it to get it |
| 335 | // started at next boot. |
| 336 | HRESULT SetupUserLevelHelper() { |
| 337 | HRESULT hr = S_OK; |
| 338 | |
| 339 | // Remove existing run-at-startup entry. |
| 340 | base::win::RemoveCommandFromAutoRun(HKEY_CURRENT_USER, kRunKeyName); |
| 341 | |
| 342 | // Build the chrome_frame_helper command line. |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 343 | base::FilePath module_path; |
| 344 | base::FilePath helper_path; |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 345 | if (PathService::Get(base::FILE_MODULE, &module_path)) { |
| 346 | module_path = module_path.DirName(); |
| 347 | helper_path = module_path.Append(kChromeFrameHelperExe); |
Ben Murdoch | 7dbb3d5 | 2013-07-17 14:55:54 +0100 | [diff] [blame] | 348 | if (!base::PathExists(helper_path)) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 349 | // If we can't find the helper in the current directory, try looking |
| 350 | // one up (this is the layout in the build output folder). |
| 351 | module_path = module_path.DirName(); |
| 352 | helper_path = module_path.Append(kChromeFrameHelperExe); |
Ben Murdoch | 7dbb3d5 | 2013-07-17 14:55:54 +0100 | [diff] [blame] | 353 | DCHECK(base::PathExists(helper_path)) << |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 354 | "Could not find chrome_frame_helper.exe."; |
| 355 | } |
| 356 | |
| 357 | // Find window handle of existing instance. |
| 358 | HWND old_window = FindWindow(kChromeFrameHelperWindowClassName, |
| 359 | kChromeFrameHelperWindowName); |
| 360 | |
Ben Murdoch | 7dbb3d5 | 2013-07-17 14:55:54 +0100 | [diff] [blame] | 361 | if (base::PathExists(helper_path)) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 362 | std::wstring helper_path_cmd(L"\""); |
| 363 | helper_path_cmd += helper_path.value(); |
| 364 | helper_path_cmd += L"\" "; |
| 365 | helper_path_cmd += kChromeFrameHelperStartupArg; |
| 366 | |
| 367 | // Add new run-at-startup entry. |
| 368 | if (!base::win::AddCommandToAutoRun(HKEY_CURRENT_USER, kRunKeyName, |
| 369 | helper_path_cmd)) { |
| 370 | hr = E_FAIL; |
| 371 | LOG(ERROR) << "Could not add helper process to auto run key."; |
| 372 | } |
| 373 | |
| 374 | // Start new instance. |
| 375 | base::LaunchOptions options; |
| 376 | options.start_hidden = true; |
| 377 | bool launched = base::LaunchProcess(helper_path.value(), options, NULL); |
| 378 | if (!launched) { |
| 379 | hr = E_FAIL; |
| 380 | PLOG(DFATAL) << "Could not launch helper process."; |
| 381 | } |
| 382 | |
| 383 | // Kill old instance using window handle. |
| 384 | if (IsWindow(old_window)) { |
| 385 | BOOL result = PostMessage(old_window, WM_CLOSE, 0, 0); |
| 386 | if (!result) { |
| 387 | PLOG(ERROR) << "Failed to post close message to old helper process: "; |
| 388 | } |
| 389 | } |
| 390 | } else { |
| 391 | hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND); |
| 392 | } |
| 393 | } else { |
| 394 | hr = E_UNEXPECTED; |
| 395 | NOTREACHED(); |
| 396 | } |
| 397 | |
| 398 | return hr; |
| 399 | } |
| 400 | |
| 401 | // To delete the user agent, set value to NULL. |
| 402 | // The is_system parameter indicates whether this is a per machine or a per |
| 403 | // user installation. |
| 404 | HRESULT SetChromeFrameUA(bool is_system, const wchar_t* value) { |
| 405 | HRESULT hr = E_FAIL; |
| 406 | HKEY parent_hive = is_system ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER; |
| 407 | |
| 408 | RegKey ua_key; |
| 409 | LONG reg_result = ua_key.Create(parent_hive, kPostPlatformUAKey, |
| 410 | KEY_READ | KEY_WRITE); |
| 411 | if (reg_result == ERROR_SUCCESS) { |
| 412 | // Make sure that we unregister ChromeFrame UA strings registered previously |
| 413 | wchar_t value_name[MAX_PATH + 1] = {}; |
| 414 | wchar_t value_data[MAX_PATH + 1] = {}; |
| 415 | |
| 416 | DWORD value_index = 0; |
| 417 | while (value_index < ua_key.GetValueCount()) { |
| 418 | DWORD name_size = arraysize(value_name); |
| 419 | DWORD value_size = arraysize(value_data); |
| 420 | DWORD type = 0; |
| 421 | LRESULT ret = ::RegEnumValue(ua_key.Handle(), value_index, value_name, |
| 422 | &name_size, NULL, &type, |
| 423 | reinterpret_cast<BYTE*>(value_data), |
| 424 | &value_size); |
| 425 | if (ret == ERROR_SUCCESS) { |
| 426 | if (StartsWith(value_name, kChromeFramePrefix, false)) { |
| 427 | ua_key.DeleteValue(value_name); |
| 428 | } else { |
| 429 | ++value_index; |
| 430 | } |
| 431 | } else { |
| 432 | break; |
| 433 | } |
| 434 | } |
| 435 | |
| 436 | std::wstring chrome_frame_ua_value_name = kChromeFramePrefix; |
| 437 | chrome_frame_ua_value_name += GetCurrentModuleVersion(); |
| 438 | if (value) { |
| 439 | ua_key.WriteValue(chrome_frame_ua_value_name.c_str(), value); |
| 440 | } |
| 441 | hr = S_OK; |
| 442 | } else { |
| 443 | DLOG(ERROR) << __FUNCTION__ << ": " << kPostPlatformUAKey |
| 444 | << ", error code = " << reg_result; |
| 445 | hr = HRESULT_FROM_WIN32(reg_result); |
| 446 | } |
| 447 | return hr; |
| 448 | } |
| 449 | |
| 450 | class SecurityDescBackup { |
| 451 | public: |
| 452 | explicit SecurityDescBackup(const std::wstring& backup_key) |
| 453 | : backup_key_name_(backup_key) {} |
| 454 | ~SecurityDescBackup() {} |
| 455 | |
| 456 | // Save given security descriptor to the backup key. |
| 457 | bool SaveSecurity(const CSecurityDesc& sd) { |
| 458 | CString str; |
| 459 | if (!sd.ToString(&str)) |
| 460 | return false; |
| 461 | |
| 462 | RegKey backup_key(HKEY_LOCAL_MACHINE, backup_key_name_.c_str(), |
| 463 | KEY_READ | KEY_WRITE); |
| 464 | if (backup_key.Valid()) { |
| 465 | return backup_key.WriteValue(NULL, str.GetString()) == ERROR_SUCCESS; |
| 466 | } |
| 467 | |
| 468 | return false; |
| 469 | } |
| 470 | |
| 471 | // Restore security descriptor from backup key to given key name. |
| 472 | bool RestoreSecurity(const wchar_t* key_name) { |
| 473 | std::wstring sddl; |
| 474 | if (!ReadBackupKey(&sddl)) |
| 475 | return false; |
| 476 | |
| 477 | // Create security descriptor from string. |
| 478 | CSecurityDesc sd; |
| 479 | if (!sd.FromString(sddl.c_str())) |
| 480 | return false; |
| 481 | |
| 482 | bool result = true; |
| 483 | // Restore DACL and Owner of the key from saved security descriptor. |
| 484 | CDacl dacl; |
| 485 | CSid owner; |
| 486 | sd.GetDacl(&dacl); |
| 487 | sd.GetOwner(&owner); |
| 488 | |
| 489 | DWORD error = ::SetNamedSecurityInfo(const_cast<wchar_t*>(key_name), |
| 490 | SE_REGISTRY_KEY, OWNER_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION, |
| 491 | const_cast<SID*>(owner.GetPSID()), NULL, |
| 492 | const_cast<ACL*>(dacl.GetPACL()), NULL); |
| 493 | |
| 494 | DeleteBackupKey(); |
| 495 | return (error == ERROR_SUCCESS); |
| 496 | } |
| 497 | |
| 498 | private: |
| 499 | // Read SDDL string from backup key |
| 500 | bool ReadBackupKey(std::wstring* sddl) { |
| 501 | RegKey backup_key(HKEY_LOCAL_MACHINE, backup_key_name_.c_str(), KEY_READ); |
| 502 | if (!backup_key.Valid()) |
| 503 | return false; |
| 504 | |
| 505 | DWORD len = 0; |
| 506 | DWORD reg_type = REG_NONE; |
| 507 | if (backup_key.ReadValue(NULL, NULL, &len, ®_type) != ERROR_SUCCESS) |
| 508 | return false; |
| 509 | DCHECK_EQ(0u, len % sizeof(wchar_t)); |
| 510 | |
| 511 | if ((len == 0) || (reg_type != REG_SZ)) |
| 512 | return false; |
| 513 | |
| 514 | size_t wchar_count = 1 + len / sizeof(wchar_t); |
| 515 | if (backup_key.ReadValue(NULL, WriteInto(sddl, wchar_count), &len, |
| 516 | ®_type) != ERROR_SUCCESS) { |
| 517 | return false; |
| 518 | } |
| 519 | |
| 520 | return true; |
| 521 | } |
| 522 | |
| 523 | void DeleteBackupKey() { |
| 524 | ::RegDeleteKey(HKEY_LOCAL_MACHINE, backup_key_name_.c_str()); |
| 525 | } |
| 526 | |
| 527 | std::wstring backup_key_name_; |
| 528 | }; |
| 529 | |
| 530 | struct TokenWithPrivileges { |
| 531 | TokenWithPrivileges() { |
| 532 | token_.GetEffectiveToken(TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY); |
| 533 | token_.GetUser(&user_); |
| 534 | } |
| 535 | |
| 536 | ~TokenWithPrivileges() { |
| 537 | token_.EnableDisablePrivileges(take_ownership_); |
| 538 | token_.EnableDisablePrivileges(restore_); |
| 539 | } |
| 540 | |
| 541 | bool EnablePrivileges() { |
| 542 | if (take_ownership_.GetCount() == 0) |
| 543 | if (!token_.EnablePrivilege(L"SeTakeOwnershipPrivilege", |
| 544 | &take_ownership_)) |
| 545 | return false; |
| 546 | |
| 547 | if (restore_.GetCount() == 0) |
| 548 | if (!token_.EnablePrivilege(L"SeRestorePrivilege", &restore_)) |
| 549 | return false; |
| 550 | |
| 551 | return true; |
| 552 | } |
| 553 | |
| 554 | const CSid& GetUser() const { |
| 555 | return user_; |
| 556 | } |
| 557 | |
| 558 | private: |
| 559 | CAccessToken token_; |
| 560 | CTokenPrivileges take_ownership_; |
| 561 | CTokenPrivileges restore_; |
| 562 | CSid user_; |
| 563 | }; |
| 564 | |
| 565 | HRESULT SetOrDeleteMimeHandlerKey(bool set, HKEY root_key) { |
| 566 | std::wstring key_name = kInternetSettings; |
| 567 | key_name.append(L"\\Secure Mime Handlers"); |
| 568 | RegKey key(root_key, key_name.c_str(), KEY_READ | KEY_WRITE); |
| 569 | if (!key.Valid()) |
| 570 | return false; |
| 571 | |
| 572 | LONG result1 = ERROR_SUCCESS; |
| 573 | LONG result2 = ERROR_SUCCESS; |
| 574 | if (set) { |
| 575 | result1 = key.WriteValue(L"ChromeTab.ChromeActiveDocument", 1); |
| 576 | result2 = key.WriteValue(L"ChromeTab.ChromeActiveDocument.1", 1); |
| 577 | } else { |
| 578 | result1 = key.DeleteValue(L"ChromeTab.ChromeActiveDocument"); |
| 579 | result2 = key.DeleteValue(L"ChromeTab.ChromeActiveDocument.1"); |
| 580 | } |
| 581 | |
| 582 | return result1 != ERROR_SUCCESS ? HRESULT_FROM_WIN32(result1) : |
| 583 | HRESULT_FROM_WIN32(result2); |
| 584 | } |
| 585 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 586 | void OnPinModule() { |
| 587 | // Pin crash reporting by leaking a reference. |
| 588 | ignore_result(new chrome_frame::ScopedCrashReporting()); |
| 589 | } |
| 590 | |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 591 | // Chrome Frame registration functions. |
| 592 | //----------------------------------------------------------------------------- |
| 593 | HRESULT RegisterSecuredMimeHandler(bool enable, bool is_system) { |
| 594 | if (!is_system) { |
| 595 | return SetOrDeleteMimeHandlerKey(enable, HKEY_CURRENT_USER); |
| 596 | } else if (base::win::GetVersion() < base::win::VERSION_VISTA) { |
| 597 | return SetOrDeleteMimeHandlerKey(enable, HKEY_LOCAL_MACHINE); |
| 598 | } |
| 599 | |
| 600 | std::wstring mime_key = kInternetSettings; |
| 601 | mime_key.append(L"\\Secure Mime Handlers"); |
| 602 | std::wstring backup_key = kInternetSettings; |
| 603 | backup_key.append(L"\\__backup_SMH__"); |
| 604 | std::wstring object_name = L"MACHINE\\"; |
| 605 | object_name.append(mime_key); |
| 606 | |
| 607 | TokenWithPrivileges token_; |
| 608 | if (!token_.EnablePrivileges()) |
| 609 | return E_ACCESSDENIED; |
| 610 | |
| 611 | // If there is a backup key - something bad happened; try to restore |
| 612 | // security on "Secure Mime Handlers" from the backup. |
| 613 | SecurityDescBackup backup(backup_key); |
| 614 | backup.RestoreSecurity(object_name.c_str()); |
| 615 | |
| 616 | // Read old security descriptor of the Mime key first. |
| 617 | CSecurityDesc sd; |
| 618 | if (!AtlGetSecurityDescriptor(object_name.c_str(), SE_REGISTRY_KEY, &sd)) { |
| 619 | return E_FAIL; |
| 620 | } |
| 621 | |
| 622 | backup.SaveSecurity(sd); |
| 623 | HRESULT hr = E_FAIL; |
| 624 | // set new owner |
| 625 | if (AtlSetOwnerSid(object_name.c_str(), SE_REGISTRY_KEY, token_.GetUser())) { |
| 626 | // set new dacl |
| 627 | CDacl new_dacl; |
| 628 | sd.GetDacl(&new_dacl); |
| 629 | new_dacl.AddAllowedAce(token_.GetUser(), GENERIC_WRITE | GENERIC_READ); |
| 630 | if (AtlSetDacl(object_name.c_str(), SE_REGISTRY_KEY, new_dacl)) { |
| 631 | hr = SetOrDeleteMimeHandlerKey(enable, HKEY_LOCAL_MACHINE); |
| 632 | } |
| 633 | } |
| 634 | |
| 635 | backup.RestoreSecurity(object_name.c_str()); |
| 636 | return hr; |
| 637 | } |
| 638 | |
| 639 | HRESULT RegisterActiveDoc(bool reg, bool is_system) { |
| 640 | // We have to call the static T::UpdateRegistry function instead of |
| 641 | // _AtlModule.UpdateRegistryFromResourceS(IDR_CHROMEFRAME_ACTIVEDOC, reg) |
| 642 | // because there is specific OLEMISC replacement. |
| 643 | return ChromeActiveDocument::UpdateRegistry(reg); |
| 644 | } |
| 645 | |
| 646 | HRESULT RegisterActiveX(bool reg, bool is_system) { |
| 647 | // We have to call the static T::UpdateRegistry function instead of |
| 648 | // _AtlModule.UpdateRegistryFromResourceS(IDR_CHROMEFRAME_ACTIVEX, reg) |
| 649 | // because there is specific OLEMISC replacement. |
| 650 | return ChromeFrameActivex::UpdateRegistry(reg); |
| 651 | } |
| 652 | |
| 653 | HRESULT RegisterElevationPolicy(bool reg, bool is_system) { |
| 654 | HRESULT hr = S_OK; |
| 655 | if (base::win::GetVersion() >= base::win::VERSION_VISTA) { |
| 656 | // Register the elevation policy. This must succeed for Chrome Frame to |
| 657 | // be able launch Chrome when running in low-integrity IE. |
| 658 | hr = _AtlModule.UpdateRegistryFromResourceS(IDR_CHROMEFRAME_ELEVATION, reg); |
| 659 | if (SUCCEEDED(hr)) { |
| 660 | // Ignore failures since old versions of IE 7 (e.g., 7.0.6000.16386, which |
| 661 | // shipped with Vista RTM) do not export IERefreshElevationPolicy. |
| 662 | RefreshElevationPolicy(); |
| 663 | } |
| 664 | } |
| 665 | return hr; |
| 666 | } |
| 667 | |
| 668 | HRESULT RegisterProtocol(bool reg, bool is_system) { |
| 669 | return _AtlModule.UpdateRegistryFromResourceS(IDR_CHROMEPROTOCOL, reg); |
| 670 | } |
| 671 | |
| 672 | HRESULT RegisterBhoClsid(bool reg, bool is_system) { |
| 673 | return Bho::UpdateRegistry(reg); |
| 674 | } |
| 675 | |
| 676 | HRESULT RegisterBhoIE(bool reg, bool is_system) { |
| 677 | if (is_system) { |
| 678 | return _AtlModule.UpdateRegistryFromResourceS(IDR_REGISTER_BHO, reg); |
| 679 | } else { |
| 680 | if (reg) { |
| 681 | // Setup the long running process: |
| 682 | return SetupUserLevelHelper(); |
| 683 | } else { |
| 684 | // Unschedule the user-level helper. Note that we don't kill it here |
| 685 | // so that during updates we don't have a time window with no running |
| 686 | // helper. Uninstalls and updates will explicitly kill the helper from |
| 687 | // within the installer. Unregister existing run-at-startup entry. |
| 688 | return base::win::RemoveCommandFromAutoRun(HKEY_CURRENT_USER, |
| 689 | kRunKeyName) ? S_OK : E_FAIL; |
| 690 | } |
| 691 | } |
| 692 | } |
| 693 | |
| 694 | HRESULT RegisterTypeLib(bool reg, bool is_system) { |
| 695 | if (reg && !is_system) { |
| 696 | // Enables the RegisterTypeLib Function function to override default |
| 697 | // registry mappings under Windows Vista Service Pack 1 (SP1), |
| 698 | // Windows Server 2008, and later operating system versions |
| 699 | typedef void (WINAPI* OaEnablePerUserTypeLibReg)(void); |
| 700 | OaEnablePerUserTypeLibReg per_user_typelib_func = |
| 701 | reinterpret_cast<OaEnablePerUserTypeLibReg>( |
| 702 | GetProcAddress(GetModuleHandle(L"oleaut32.dll"), |
| 703 | "OaEnablePerUserTLibRegistration")); |
| 704 | if (per_user_typelib_func) { |
| 705 | (*per_user_typelib_func)(); |
| 706 | } |
| 707 | } |
| 708 | return reg ? |
| 709 | UtilRegisterTypeLib(_AtlComModule.m_hInstTypeLib, |
| 710 | NULL, !is_system) : |
| 711 | UtilUnRegisterTypeLib(_AtlComModule.m_hInstTypeLib, |
| 712 | NULL, !is_system); |
| 713 | } |
| 714 | |
| 715 | HRESULT RegisterLegacyNPAPICleanup(bool reg, bool is_system) { |
| 716 | if (!reg) { |
| 717 | _AtlModule.UpdateRegistryFromResourceS(IDR_CHROMEFRAME_NPAPI, reg); |
| 718 | UtilRemovePersistentNPAPIMarker(); |
| 719 | } |
| 720 | // Ignore failures. |
| 721 | return S_OK; |
| 722 | } |
| 723 | |
| 724 | HRESULT RegisterAppId(bool reg, bool is_system) { |
| 725 | return _AtlModule.UpdateRegistryAppId(reg); |
| 726 | } |
| 727 | |
| 728 | HRESULT RegisterUserAgent(bool reg, bool is_system) { |
| 729 | if (reg) { |
| 730 | return SetChromeFrameUA(is_system, L"1"); |
| 731 | } else { |
| 732 | return SetChromeFrameUA(is_system, NULL); |
| 733 | } |
| 734 | } |
| 735 | |
| 736 | enum RegistrationStepId { |
| 737 | kStepSecuredMimeHandler = 0, |
| 738 | kStepActiveDoc = 1, |
| 739 | kStepActiveX = 2, |
| 740 | kStepElevationPolicy = 3, |
| 741 | kStepProtocol = 4, |
| 742 | kStepBhoClsid = 5, |
| 743 | kStepBhoRegistration = 6, |
| 744 | kStepRegisterTypeLib = 7, |
| 745 | kStepNpapiCleanup = 8, |
| 746 | kStepAppId = 9, |
| 747 | kStepUserAgent = 10, |
| 748 | kStepEnd = 11 |
| 749 | }; |
| 750 | |
| 751 | enum RegistrationFlags { |
| 752 | ACTIVEX = 0x0001, |
| 753 | ACTIVEDOC = 0x0002, |
| 754 | GCF_PROTOCOL = 0x0004, |
| 755 | BHO_CLSID = 0x0008, |
| 756 | BHO_REGISTRATION = 0x0010, |
| 757 | TYPELIB = 0x0020, |
| 758 | |
| 759 | ALL = 0xFFFF |
| 760 | }; |
| 761 | |
| 762 | // Mux the failure step into the hresult. We take only the first four bits |
| 763 | // and stick those into the top four bits of the facility code. We also set the |
| 764 | // Customer bit to be polite. Graphically, we write our error code to the |
| 765 | // bits marked with ^: |
| 766 | // 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 |
| 767 | // 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 |
| 768 | // +---+-+-+-----------------------+-------------------------------+ |
| 769 | // |Sev|C|R| Facility | Code | |
| 770 | // +---+-+-+-----------------------+-------------------------------+ |
| 771 | // ^ ^ ^ ^ ^ |
| 772 | // See http://msdn.microsoft.com/en-us/library/cc231198(PROT.10).aspx for |
| 773 | // more details on HRESULTS. |
| 774 | // |
| 775 | // The resulting error can be extracted by: |
| 776 | // error_code = (fiddled_hr & 0x07800000) >> 23 |
| 777 | HRESULT MuxErrorIntoHRESULT(HRESULT hr, int error_code) { |
| 778 | DCHECK_GE(error_code, 0); |
| 779 | DCHECK_LT(error_code, kStepEnd); |
| 780 | COMPILE_ASSERT(kStepEnd <= 0xF, update_error_muxing_too_many_steps); |
| 781 | |
| 782 | // Check that our four desired bits are clear. |
| 783 | // 0xF87FFFFF == 11111000011111111111111111111111 |
| 784 | DCHECK_EQ(static_cast<HRESULT>(hr & 0xF87FFFFF), hr); |
| 785 | |
| 786 | HRESULT fiddled_hr = ((error_code & 0xF) << 23) | hr; |
| 787 | fiddled_hr |= 1 << 29; // Set the customer bit. |
| 788 | |
| 789 | return fiddled_hr; |
| 790 | } |
| 791 | |
| 792 | HRESULT CustomRegistration(uint16 reg_flags, bool reg, bool is_system) { |
| 793 | if (reg && (reg_flags & (ACTIVEDOC | ACTIVEX))) |
| 794 | reg_flags |= (TYPELIB | GCF_PROTOCOL); |
| 795 | |
| 796 | // Set the flag that gets checked in AddCommonRGSReplacements before doing |
| 797 | // registration work. |
| 798 | _AtlModule.do_system_registration_ = is_system; |
| 799 | |
| 800 | typedef HRESULT (*RegistrationFn)(bool reg, bool is_system); |
| 801 | struct RegistrationStep { |
| 802 | RegistrationStepId id; |
| 803 | uint16 condition; |
| 804 | RegistrationFn func; |
| 805 | }; |
| 806 | static const RegistrationStep registration_steps[] = { |
| 807 | { kStepSecuredMimeHandler, ACTIVEDOC, &RegisterSecuredMimeHandler }, |
| 808 | { kStepActiveDoc, ACTIVEDOC, &RegisterActiveDoc }, |
| 809 | { kStepActiveX, ACTIVEX, &RegisterActiveX }, |
| 810 | { kStepElevationPolicy, (ACTIVEDOC | ACTIVEX), &RegisterElevationPolicy }, |
| 811 | { kStepProtocol, GCF_PROTOCOL, &RegisterProtocol }, |
| 812 | { kStepBhoClsid, BHO_CLSID, &RegisterBhoClsid }, |
| 813 | { kStepBhoRegistration, BHO_REGISTRATION, &RegisterBhoIE }, |
| 814 | { kStepRegisterTypeLib, TYPELIB, &RegisterTypeLib }, |
| 815 | { kStepNpapiCleanup, ALL, &RegisterLegacyNPAPICleanup }, |
| 816 | { kStepAppId, ALL, &RegisterAppId }, |
| 817 | { kStepUserAgent, ALL, &RegisterUserAgent } |
| 818 | }; |
| 819 | |
| 820 | HRESULT hr = S_OK; |
| 821 | |
| 822 | bool rollback = false; |
| 823 | int failure_step = 0; |
| 824 | HRESULT step_hr = S_OK; |
| 825 | for (int step = 0; step < arraysize(registration_steps); ++step) { |
| 826 | if ((reg_flags & registration_steps[step].condition) != 0) { |
| 827 | step_hr = registration_steps[step].func(reg, is_system); |
| 828 | if (FAILED(step_hr)) { |
| 829 | // Store only the first failing HRESULT with the step value muxed in. |
| 830 | if (hr == S_OK) { |
| 831 | hr = MuxErrorIntoHRESULT(step_hr, step); |
| 832 | } |
| 833 | |
| 834 | // On registration if a step fails, we abort and rollback. |
| 835 | if (reg) { |
| 836 | rollback = true; |
| 837 | failure_step = step; |
| 838 | break; |
| 839 | } |
| 840 | } |
| 841 | } |
| 842 | } |
| 843 | |
| 844 | if (rollback) { |
| 845 | DCHECK(reg); |
| 846 | // Rollback the failing action and all preceding ones. |
| 847 | for (int step = failure_step; step >= 0; --step) { |
| 848 | registration_steps[step].func(!reg, is_system); |
| 849 | } |
| 850 | } |
| 851 | |
| 852 | return hr; |
| 853 | } |
| 854 | |
| 855 | } // namespace |
| 856 | |
| 857 | // DLL Entry Point |
| 858 | extern "C" BOOL WINAPI DllMain(HINSTANCE instance, |
| 859 | DWORD reason, |
| 860 | LPVOID reserved) { |
| 861 | UNREFERENCED_PARAMETER(instance); |
| 862 | if (reason == DLL_PROCESS_ATTACH) { |
| 863 | #ifndef NDEBUG |
| 864 | // Silence traces from the ATL registrar to reduce the log noise. |
| 865 | ATL::CTrace::s_trace.ChangeCategory(atlTraceRegistrar, 0, |
| 866 | ATLTRACESTATUS_DISABLED); |
| 867 | #endif |
| 868 | InitGoogleUrl(); |
| 869 | |
| 870 | g_exit_manager = new base::AtExitManager(); |
| 871 | CommandLine::Init(0, NULL); |
Ben Murdoch | eb525c5 | 2013-07-10 11:40:50 +0100 | [diff] [blame] | 872 | logging::LoggingSettings settings; |
| 873 | settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG; |
| 874 | logging::InitLogging(settings); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 875 | |
| 876 | // Log the same items as Chrome. |
| 877 | logging::SetLogItems(true, // enable_process_id |
| 878 | true, // enable_thread_id |
| 879 | false, // enable_timestamp |
| 880 | true); // enable_tickcount |
| 881 | |
| 882 | DllRedirector* dll_redirector = DllRedirector::GetInstance(); |
| 883 | DCHECK(dll_redirector); |
| 884 | |
| 885 | if (!dll_redirector->RegisterAsFirstCFModule()) { |
| 886 | // Someone else was here first, try and get a pointer to their |
| 887 | // DllGetClassObject export: |
| 888 | g_dll_get_class_object_redir_ptr = |
| 889 | dll_redirector->GetDllGetClassObjectPtr(); |
| 890 | DCHECK(g_dll_get_class_object_redir_ptr != NULL) |
| 891 | << "Found CF module with no DllGetClassObject export."; |
| 892 | } |
| 893 | |
| 894 | // Enable trace control and transport through event tracing for Windows. |
| 895 | logging::LogEventProvider::Initialize(kChromeFrameProvider); |
| 896 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 897 | // Set a callback so that crash reporting can be pinned when the module is |
| 898 | // pinned. |
| 899 | chrome_frame::SetPinModuleCallback(&OnPinModule); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 900 | } else if (reason == DLL_PROCESS_DETACH) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 901 | DllRedirector* dll_redirector = DllRedirector::GetInstance(); |
| 902 | DCHECK(dll_redirector); |
| 903 | dll_redirector->UnregisterAsFirstCFModule(); |
| 904 | |
| 905 | g_patch_helper.UnpatchIfNeeded(); |
| 906 | |
| 907 | delete g_exit_manager; |
| 908 | g_exit_manager = NULL; |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 909 | } |
| 910 | return _AtlModule.DllMain(reason, reserved); |
| 911 | } |
| 912 | |
| 913 | // Used to determine whether the DLL can be unloaded by OLE |
| 914 | STDAPI DllCanUnloadNow() { |
| 915 | return _AtlModule.DllCanUnloadNow(); |
| 916 | } |
| 917 | |
| 918 | // Returns a class factory to create an object of the requested type |
| 919 | STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv) { |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 920 | chrome_frame::ScopedCrashReporting crash_reporting; |
| 921 | |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 922 | // If we found another module present when we were loaded, then delegate to |
| 923 | // that: |
| 924 | if (g_dll_get_class_object_redir_ptr) { |
| 925 | return g_dll_get_class_object_redir_ptr(rclsid, riid, ppv); |
| 926 | } |
| 927 | |
| 928 | // Enable sniffing and switching only if asked for BHO |
| 929 | // (we use BHO to get loaded in IE). |
| 930 | if (rclsid == CLSID_ChromeFrameBHO) { |
| 931 | g_patch_helper.InitializeAndPatchProtocolsIfNeeded(); |
| 932 | } |
| 933 | |
| 934 | return _AtlModule.DllGetClassObject(rclsid, riid, ppv); |
| 935 | } |
| 936 | |
| 937 | // DllRegisterServer - Adds entries to the system registry |
| 938 | STDAPI DllRegisterServer() { |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 939 | chrome_frame::ScopedCrashReporting crash_reporting; |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 940 | uint16 flags = ACTIVEX | ACTIVEDOC | TYPELIB | GCF_PROTOCOL | |
| 941 | BHO_CLSID | BHO_REGISTRATION; |
| 942 | |
| 943 | HRESULT hr = CustomRegistration(flags, true, true); |
| 944 | if (SUCCEEDED(hr)) { |
| 945 | SetupRunOnce(); |
| 946 | } |
| 947 | |
| 948 | return hr; |
| 949 | } |
| 950 | |
| 951 | // DllUnregisterServer - Removes entries from the system registry |
| 952 | STDAPI DllUnregisterServer() { |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 953 | chrome_frame::ScopedCrashReporting crash_reporting; |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 954 | HRESULT hr = CustomRegistration(ALL, false, true); |
| 955 | return hr; |
| 956 | } |
| 957 | |
| 958 | // DllRegisterUserServer - Adds entries to the HKCU hive in the registry. |
| 959 | STDAPI DllRegisterUserServer() { |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 960 | chrome_frame::ScopedCrashReporting crash_reporting; |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 961 | UINT flags = ACTIVEX | ACTIVEDOC | TYPELIB | GCF_PROTOCOL | |
| 962 | BHO_CLSID | BHO_REGISTRATION; |
| 963 | |
| 964 | HRESULT hr = CustomRegistration(flags, TRUE, false); |
| 965 | if (SUCCEEDED(hr)) { |
| 966 | SetupRunOnce(); |
| 967 | } |
| 968 | |
| 969 | return hr; |
| 970 | } |
| 971 | |
| 972 | // DllUnregisterUserServer - Removes entries from the HKCU hive in the registry. |
| 973 | STDAPI DllUnregisterUserServer() { |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 974 | chrome_frame::ScopedCrashReporting crash_reporting; |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 975 | HRESULT hr = CustomRegistration(ALL, FALSE, false); |
| 976 | return hr; |
| 977 | } |
| 978 | |
| 979 | // Object entries go here instead of with each object, so that we can move |
| 980 | // the objects to a lib. Also reduces magic. |
| 981 | OBJECT_ENTRY_AUTO(CLSID_ChromeFrameBHO, Bho) |
| 982 | OBJECT_ENTRY_AUTO(__uuidof(ChromeActiveDocument), ChromeActiveDocument) |
| 983 | OBJECT_ENTRY_AUTO(__uuidof(ChromeFrame), ChromeFrameActivex) |
| 984 | OBJECT_ENTRY_AUTO(__uuidof(ChromeProtocol), ChromeProtocol) |