Handle automation server crashes.

chrome_frame/chrome_active_document.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.
 
 // Implementation of ChromeActiveDocument
 #include "chrome_frame/chrome_active_document.h"
 
 #include <hlink.h>
 #include <htiface.h>
 #include <initguid.h>
@@ skipping 50 matching lines @@
   0  // The Last data must be 0 to indicate the end of the encoding id array.
 };
 
 ChromeActiveDocument::ChromeActiveDocument()
     : first_navigation_(true),
       is_automation_client_reused_(false),
       popup_allowed_(false),
       accelerator_table_(NULL) {
   TRACE_EVENT_BEGIN("chromeframe.createactivedocument", this, "");
 
-  url_fetcher_.set_frame_busting(false);
+  url_fetcher_->set_frame_busting(false);
   memset(&navigation_info_, 0, sizeof(navigation_info_));
 }
 
 HRESULT ChromeActiveDocument::FinalConstruct() {
   // If we have a cached ChromeActiveDocument instance in TLS, then grab
   // ownership of the cached document's automation client. This is an
   // optimization to get Chrome active documents to load faster.
   ChromeActiveDocument* cached_document = g_active_doc_cache.Get();
   if (cached_document && cached_document->IsValid()) {
     DCHECK(automation_client_.get() == NULL);
     automation_client_.swap(cached_document->automation_client_);
     DLOG(INFO) << "Reusing automation client instance from "
                << cached_document;
     DCHECK(automation_client_.get() != NULL);
-    automation_client_->Reinitialize(this, &url_fetcher_);
+    automation_client_->Reinitialize(this, url_fetcher_.get());
     is_automation_client_reused_ = true;
   } else {
     // The FinalConstruct implementation in the ChromeFrameActivexBase class
     // i.e. Base creates an instance of the ChromeFrameAutomationClient class
     // and initializes it, which would spawn a new Chrome process, etc.
     // We don't want to be doing this if we have a cached document, whose
     // automation client instance can be reused.
     HRESULT hr = BaseActiveX::FinalConstruct();
     if (FAILED(hr))
       return hr;
@@ skipping 173 matching lines @@
   ChromeFrameUrl cf_url;
   if (!cf_url.Parse(url)) {
     DLOG(WARNING) << __FUNCTION__ << " Failed to parse url:" << url;
     return E_INVALIDARG;
   }
 
   if (!CanNavigateInFullTabMode(cf_url, security_manager_)) {
     return E_INVALIDARG;
   }
 
-  std::string referrer = mgr ? mgr->referrer() : EmptyString();
+  std::string referrer(mgr ? mgr->referrer() : EmptyString());
+
   // With CTransaction patch we have more robust way to grab the referrer for
   // each top-level-switch-to-CF request by peeking at our sniffing data
   // object that lives inside the bind context.
   if (g_patch_helper.state() == PatchHelper::PATCH_PROTOCOL && info) {
     scoped_refptr<ProtData> prot_data = info->get_prot_data();
     if (prot_data)
       referrer = prot_data->referrer();
   }
 
   if (!LaunchUrl(cf_url, referrer)) {
     NOTREACHED() << __FUNCTION__ << " Failed to launch url:" << url;
     return E_INVALIDARG;
   }
 
   if (!cf_url.is_chrome_protocol() && !cf_url.attach_to_external_tab())
-    url_fetcher_.SetInfoForUrl(cf_url.url(), moniker_name, bind_context);
+    url_fetcher_->SetInfoForUrl(cf_url.url(), moniker_name, bind_context);
 
   THREAD_SAFE_UMA_HISTOGRAM_CUSTOM_COUNTS("ChromeFrame.FullTabLaunchType",
                                           cf_url.is_chrome_protocol(),
                                           0, 1, 2);
   return S_OK;
 }
 
 STDMETHODIMP ChromeActiveDocument::Save(IMoniker* moniker_name,
                                         LPBC bind_context,
                                         BOOL remember) {
@@ skipping 58 matching lines @@
 STDMETHODIMP ChromeActiveDocument::Exec(const GUID* cmd_group_guid,
                                         DWORD command_id,
                                         DWORD cmd_exec_opt,
                                         VARIANT* in_args,
                                         VARIANT* out_args) {
   DLOG(INFO) << __FUNCTION__ << " Cmd id =" << command_id;
   // Bail out if we have been uninitialized.
   if (automation_client_.get() && automation_client_->tab()) {
     return ProcessExecCommand(cmd_group_guid, command_id, cmd_exec_opt,
                               in_args, out_args);
+  } else if (command_id == OLECMDID_REFRESH && cmd_group_guid == NULL) {
+    // If the automation server has crashed and the user is refreshing the
+    // page, let OnRefreshPage attempt to recover.
+    OnRefreshPage(cmd_group_guid, command_id, cmd_exec_opt, in_args, out_args);
   }
+
   return OLECMDERR_E_NOTSUPPORTED;
 }
 
 STDMETHODIMP ChromeActiveDocument::LoadHistory(IStream* stream,
                                                IBindCtx* bind_context) {
   // Read notes in ChromeActiveDocument::SaveHistory
   DCHECK(stream);
   LARGE_INTEGER offset = {0};
   ULARGE_INTEGER cur_pos = {0};
   STATSTG statstg = {0};
@@ skipping 451 matching lines @@
                                                    VARIANT* out_args) {
   // Always return URLZONE_INTERNET since that is the Chrome's behaviour.
   // Correct step is to use MapUrlToZone().
   if (out_args != NULL) {
     out_args->vt = VT_UI4;
     out_args->ulVal = URLZONE_INTERNET;
   }
 }
 
 void ChromeActiveDocument::OnDisplayPrivacyInfo() {
-  privacy_info_ = url_fetcher_.privacy_info();
+  privacy_info_ = url_fetcher_->privacy_info();
   Reset();
   DoPrivacyDlg(m_hWnd, url_, this, TRUE);
 }
 
 void ChromeActiveDocument::OnGetZoomRange(const GUID* cmd_group_guid,
                                           DWORD command_id,
                                           DWORD cmd_exec_opt,
                                           VARIANT* in_args,
                                           VARIANT* out_args) {
   if (out_args != NULL) {
@@ skipping 124 matching lines @@
   return hr;
 }
 
 bool ChromeActiveDocument::LaunchUrl(const ChromeFrameUrl& cf_url,
                                      const std::string& referrer) {
   DCHECK(automation_client_.get() != NULL);
   DCHECK(!cf_url.url().empty());
 
   url_.Allocate(cf_url.url().c_str());
 
-  std::string utf8_url;
-  WideToUTF8(url_, url_.Length(), &utf8_url);
-
-  DLOG(INFO) << "this:" << this << " url is:" << url_;
+  std::string utf8_url(WideToUTF8(cf_url.url()));
+  DLOG(INFO) << "this:" << this << " url is:" << utf8_url;
 
   if (cf_url.attach_to_external_tab()) {
     dimensions_ = cf_url.dimensions();
     automation_client_->AttachExternalTab(cf_url.cookie());
     SetWindowDimensions();
   } else if (!automation_client_->InitiateNavigation(utf8_url,
                                                      referrer,
                                                      is_privileged_)) {
     DLOG(ERROR) << "Invalid URL: " << url_;
     Error(L"Invalid URL");
     url_.Reset();
     return false;
   }
 
   if (is_automation_client_reused_)
     return true;
 
-  automation_client_->SetUrlFetcher(&url_fetcher_);
+  automation_client_->SetUrlFetcher(url_fetcher_.get());
 
+  GURL url(utf8_url);
   return InitializeAutomation(GetHostProcessName(false), L"", IsIEInPrivate(),
-                              false, GURL(utf8_url), GURL(referrer));
+                              false, url, GURL(referrer));
 }
 
 
 HRESULT ChromeActiveDocument::OnRefreshPage(const GUID* cmd_group_guid,
     DWORD command_id, DWORD cmd_exec_opt, VARIANT* in_args, VARIANT* out_args) {
+  DLOG(INFO) << __FUNCTION__;
   popup_allowed_ = false;
   if (in_args->vt == VT_I4 &&
       in_args->lVal & OLECMDIDF_REFRESH_PAGEACTION_POPUPWINDOW) {
     popup_allowed_ = true;
 
     // Ask the yellow security band to change the text and icon and to remain
     // visible.
     IEExec(&CGID_DocHostCommandHandler, OLECMDID_PAGEACTIONBLOCKED,
-      0x80000000 | OLECMDIDF_WINDOWSTATE_USERVISIBLE_VALID, NULL, NULL);
+        0x80000000 | OLECMDIDF_WINDOWSTATE_USERVISIBLE_VALID, NULL, NULL);
   }
 
   TabProxy* tab_proxy = GetTabProxy();
-  if (tab_proxy)
+  if (tab_proxy) {
     tab_proxy->ReloadAsync();
+  } else {
+    DLOG(ERROR) << "No automation proxy";
+    // The current url request manager (url_fetcher_) has been switched to
+    // a stopping state so we need to reset it and get a new one for the new
+    // automation server.
+    ResetUrlRequestManager();
+    url_fetcher_->set_frame_busting(false);
+    // And now launch the current URL again.  This starts a new server process.
+    DCHECK(navigation_info_.url.is_valid());
+    ChromeFrameUrl cf_url;
+    cf_url.Parse(UTF8ToWide(navigation_info_.url.spec()));
+    LaunchUrl(cf_url, navigation_info_.referrer.spec());
+  }
 
   return S_OK;
 }
 
-
 HRESULT ChromeActiveDocument::SetPageFontSize(const GUID* cmd_group_guid,
                                               DWORD command_id,
                                               DWORD cmd_exec_opt,
                                               VARIANT* in_args,
                                               VARIANT* out_args) {
   if (!automation_client_.get()) {
     NOTREACHED() << "Invalid automation client";
     return E_FAIL;
   }
 
@@ skipping 202 matching lines @@
     web_browser2->put_Height(dimensions_.height());
     web_browser2->put_Left(dimensions_.x());
     web_browser2->put_Top(dimensions_.y());
     web_browser2->put_MenuBar(VARIANT_FALSE);
     web_browser2->put_ToolBar(VARIANT_FALSE);
 
     dimensions_.set_height(0);
     dimensions_.set_width(0);
   }
 }