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