Boot prefetch optimization for Chrome Frame (experimental)...

chrome_frame/chrome_tab.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // chrome_tab.cc : Implementation of DLL Exports.
 
 // Include without path to make GYP build see it.
 #include "chrome_tab.h"  // NOLINT
 
 #include <atlsecurity.h>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
 #include "base/lock.h"
 #include "base/logging.h"
 #include "base/logging_win.h"
 #include "base/path_service.h"
 #include "base/registry.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
 #include "base/win_util.h"
 #include "chrome/common/chrome_constants.h"
+#include "chrome/common/chrome_switches.h"
+#include "chrome/installer/util/google_update_settings.h"
 #include "grit/chrome_frame_resources.h"
 #include "chrome_frame/bho.h"
 #include "chrome_frame/chrome_active_document.h"
 #include "chrome_frame/chrome_frame_activex.h"
 #include "chrome_frame/chrome_frame_automation.h"
 #include "chrome_frame/exception_barrier.h"
 #include "chrome_frame/chrome_frame_reporting.h"
 #include "chrome_frame/chrome_launcher_utils.h"
 #include "chrome_frame/chrome_protocol.h"
 #include "chrome_frame/module_utils.h"
@@ skipping 17 matching lines @@
 static const wchar_t kBhoRegistryPath[] =
     L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer"
     L"\\Browser Helper Objects";
 
 const wchar_t kInternetSettings[] =
     L"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings";
 
 const wchar_t kProtocolHandlers[] =
     L"Software\\Classes\\Protocols\\Handler";
 
+const wchar_t kRunOnce[] =
+    L"Software\\Microsoft\\Windows\\CurrentVersion\\RunOnce";
+
 const wchar_t kBhoNoLoadExplorerValue[] = L"NoExplorer";
 
 // {0562BFC3-2550-45b4-BD8E-A310583D3A6F}
 static const GUID kChromeFrameProvider =
     { 0x562bfc3, 0x2550, 0x45b4,
         { 0xbd, 0x8e, 0xa3, 0x10, 0x58, 0x3d, 0x3a, 0x6f } };
 
 // Object entries go here instead of with each object, so that we can move
 // the objects to a lib. Also reduces magic.
 OBJECT_ENTRY_AUTO(CLSID_ChromeFrameBHO, Bho)
@@ skipping 126 matching lines @@
     g_exit_manager = NULL;
     ShutdownCrashReporting();
   }
   return _AtlModule.DllMain(reason, reserved);
 }
 
 #ifdef _MANAGED
 #pragma managed(pop)
 #endif
 
-const wchar_t kPostPlatformUAKey[] =
-    L"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\"
-    L"User Agent\\Post Platform";
-const wchar_t kClockUserAgent[] = L"chromeframe";
-
-// To delete the clock user agent, set value to NULL.
-// TODO(tommi): Remove this method when it's no longer used.
-HRESULT SetClockUserAgent(const wchar_t* value) {
-  HRESULT hr;
-  RegKey ua_key;
-  if (ua_key.Create(HKEY_LOCAL_MACHINE, kPostPlatformUAKey, KEY_WRITE)) {
-    if (value) {
-      ua_key.WriteValue(kClockUserAgent, value);
-    } else {
-      ua_key.DeleteValue(kClockUserAgent);
-    }
-    hr = S_OK;
-  } else {
-    DLOG(ERROR) << __FUNCTION__ << ": " << kPostPlatformUAKey;
-    hr = E_UNEXPECTED;
-  }
-
-  return hr;
-}
-
 HRESULT RefreshElevationPolicy() {
   const wchar_t kIEFrameDll[] = L"ieframe.dll";
   const char kIERefreshPolicy[] = "IERefreshElevationPolicy";
   HRESULT hr = E_NOTIMPL;
 
   // Stick an SEH in the chain to prevent the VEH from picking up on first
   // chance exceptions caused by loading ieframe.dll. Use the vanilla
   // ExceptionBarrier to report any exceptions that do make their way to us
   // though.
   ExceptionBarrier barrier;
@@ skipping 41 matching lines @@
 
   ie_bho_key.WriteValue(kBhoNoLoadExplorerValue, 1);
   DLOG(INFO) << "Registered ChromeTab BHO";
 
   // We now add the chromeframe user agent at runtime.
   RefreshElevationPolicy();
   return S_OK;
 }
 
 HRESULT UnregisterChromeTabBHO() {
-  // TODO(tommi): remove this in future versions.
-  SetClockUserAgent(NULL);
-
   RegKey ie_bho_key;
   if (!ie_bho_key.Open(HKEY_LOCAL_MACHINE, kBhoRegistryPath,
                        KEY_READ | KEY_WRITE)) {
     DLOG(WARNING) << "Failed to open registry key "
                   << kBhoRegistryPath
                   << " for write.";
     return E_FAIL;
   }
 
   wchar_t bho_class_id_as_string[MAX_PATH] = {0};
   StringFromGUID2(CLSID_ChromeFrameBHO, bho_class_id_as_string,
                   arraysize(bho_class_id_as_string));
 
   if (!ie_bho_key.DeleteKey(bho_class_id_as_string)) {
     DLOG(WARNING) << "Failed to delete bho registry key "
                   << bho_class_id_as_string
                   << " under "
                   << kBhoRegistryPath;
     return E_FAIL;
   }
 
   DLOG(INFO) << "Unregistered ChromeTab BHO";
   return S_OK;
 }
 
-HRESULT CleanupCFProtocol() {
-  RegKey protocol_handlers_key;
-  if (protocol_handlers_key.Open(HKEY_LOCAL_MACHINE, kProtocolHandlers,
-                                 KEY_READ | KEY_WRITE)) {
-    RegKey cf_protocol_key;
-    if (cf_protocol_key.Open(protocol_handlers_key.Handle(), L"cf",
-                             KEY_QUERY_VALUE)) {
-      std::wstring protocol_clsid_string;
-      if (cf_protocol_key.ReadValue(L"CLSID", &protocol_clsid_string)) {
-        CLSID protocol_clsid = {0};
-        IIDFromString(protocol_clsid_string.c_str(), &protocol_clsid);
-        if (IsEqualGUID(protocol_clsid, CLSID_ChromeProtocol))
-          protocol_handlers_key.DeleteKey(L"cf");
-      }
-    }
+// Experimental boot prefetch optimization for Chrome Frame
+//
+// If chrome is warmed up during a single reboot, it gets paged
+// in for subsequent reboots and the cold startup times essentially
+// look like warm times thereafter! The 'warm up' is done by
+// setting up a 'RunOnce' key during DLLRegisterServer of
+// npchrome_frame.dll.
+//
+// This works because chrome prefetch becomes part of boot
+// prefetch file ntosboot-b00dfaad.pf and paged in on subsequent
+// reboots. As long as the sytem does not undergo significant
+// memory pressure those pages remain in memory and we get pretty
+// amazing startup times, down to about 300 ms from 1200 ms
+//
+// The downside is:
+// - Whether chrome frame is used or not, there's a read penalty
+//  (1200-300 =) 900 ms for every boot.
+// - Heavy system memory usage after reboot will nullify the benefits
+//  but the user will still pay the cost.
+// - Overall the time saved will always be less than total time spent
+//  paging in chrome
+// - We are not sure when the chrome 'warm up' will age out from the
+//  boot prefetch file.
+//
+// The idea here is to try this out on chrome frame dev channel
+// and see if it produces a significant drift in startup numbers.
+HRESULT SetupRunOnce() {
+  if (win_util::GetWinVersion() >= win_util::WINVERSION_VISTA)
+    return S_OK;
+
+  std::wstring channel_name;
+  if (!GoogleUpdateSettings::GetChromeChannel(true, &channel_name) ||
+      (0 != lstrcmpiW(L"dev", channel_name.c_str()))) {
+    return S_OK;
+  }
+
+  RegKey run_once;
+  if (run_once.Create(HKEY_CURRENT_USER, kRunOnce, KEY_READ | KEY_WRITE)) {
+    CommandLine run_once_command(chrome_launcher::GetChromeExecutablePath());
+    run_once_command.AppendSwitchWithValue(
+        switches::kAutomationClientChannelID, L"0");
+    run_once_command.AppendSwitch(switches::kChromeFrame);
+    run_once.WriteValue(L"A", run_once_command.command_line_string().c_str());
   }
 
   return S_OK;
 }
 
 // Used to determine whether the DLL can be unloaded by OLE
 STDAPI DllCanUnloadNow() {
   return _AtlModule.DllCanUnloadNow();
 }
 
@@ skipping 14 matching lines @@
   // registers object, typelib and all interfaces in typelib
   HRESULT hr = _AtlModule.DllRegisterServer(TRUE);
 
   if (SUCCEEDED(hr)) {
     // Best effort attempt to register the BHO. At this point we silently
     // ignore any errors during registration. There are some traces emitted
     // to the debug log.
     RegisterChromeTabBHO();
     if (!RegisterSecuredMimeHandler(true))
       hr = E_FAIL;
+    SetupRunOnce();
   }
 
   if (UtilIsPersistentNPAPIMarkerSet()) {
     hr = _AtlModule.UpdateRegistryFromResourceS(IDR_CHROMEFRAME_NPAPI, TRUE);
   }
 
   return hr;
 }
 
 // DllUnregisterServer - Removes entries from the system registry
 STDAPI DllUnregisterServer() {
   HRESULT hr = _AtlModule.DllUnregisterServer(TRUE);
 
   if (SUCCEEDED(hr)) {
     // Best effort attempt to unregister the BHO. At this point we silently
     // ignore any errors during unregistration. There are some traces emitted
     // to the debug log.
     UnregisterChromeTabBHO();
     if (!RegisterSecuredMimeHandler(false))
       hr = E_FAIL;
   }
 
   if (UtilIsNPAPIPluginRegistered()) {
     hr = _AtlModule.UpdateRegistryFromResourceS(IDR_CHROMEFRAME_NPAPI, FALSE);
   }
 
-  // TODO(joshia): Remove after 2 refresh releases
-  CleanupCFProtocol();
   return hr;
 }
 
 // Registers the NPAPI plugin and sets the persistent marker that tells us
 // to re-register it through updates.
 STDAPI RegisterNPAPIPlugin() {
   HRESULT hr = _AtlModule.UpdateRegistryFromResourceS(IDR_CHROMEFRAME_NPAPI,
                                                       TRUE);
   if (SUCCEEDED(hr)) {
     if (!UtilChangePersistentNPAPIMarker(true)) {
@@ skipping 185 matching lines @@
     sd.GetDacl(&new_dacl);
     new_dacl.AddAllowedAce(token_.GetUser(), GENERIC_WRITE | GENERIC_READ);
     if (AtlSetDacl(object_name.c_str(), SE_REGISTRY_KEY, new_dacl)) {
       result = SetOrDeleteMimeHandlerKey(enable);
     }
   }
 
   backup.RestoreSecurity(object_name.c_str());
   return result;
 }