Handle automation server crashes.

chrome_frame/urlmon_url_request.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.
 
 #include "chrome_frame/urlmon_url_request.h"
 
 #include <wininet.h>
 #include <urlmon.h>
 
 #include "base/logging.h"
@@ skipping 166 matching lines @@
         // Just drop the data.
       }
       DLOG_IF(WARNING, hr != E_PENDING) << __FUNCTION__ <<
           StringPrintf(" expected E_PENDING but got 0x%08X", hr);
     }
   }
 }
 
 size_t UrlmonUrlRequest::SendDataToDelegate(size_t bytes_to_read) {
   DCHECK_EQ(thread_, PlatformThread::CurrentId());
-  DCHECK(id() != -1);
+  DCHECK_NE(id(), -1);
   DCHECK_GT(bytes_to_read, 0U);
   size_t bytes_copied = 0;
   if (delegate_) {
     std::string read_data;
     if (cache_) {
       HRESULT hr = ReadStream(cache_, bytes_to_read, &read_data);
       if (hr == S_FALSE || read_data.length() < bytes_to_read) {
         DLOG(INFO) << __FUNCTION__ << me() << "all cached data read";
         cache_.Release();
       }
@@ skipping 15 matching lines @@
       // stream. Clear it to ensure that OnStopBinding correctly sends over the
       // response end notification to chrome.
       if (hr == S_FALSE)
         pending_data_.Release();
     }
 
     bytes_copied = read_data.length();
 
     if (bytes_copied) {
       ++calling_delegate_;
-      DCHECK(id() != -1);
+      DCHECK_NE(id(), -1);
       delegate_->OnReadComplete(id(), read_data);
       --calling_delegate_;
     }
   } else {
     DLOG(ERROR) << __FUNCTION__ << me() << "no delegate";
   }
 
   return bytes_copied;
 }
 
@@ skipping 134 matching lines @@
     // The network policy in Chrome network is that error code/end_of_stream
     // should be returned only as a result of read (or start) request.
     // Here are the possible cases:
     // pending_data_|pending_read
     //     FALSE  |FALSE   => EndRequest if no headers, otherwise wait for Read.
     //     FALSE  |TRUE    => EndRequest.
     //     TRUE   |FALSE   => Wait for Read.
     //     TRUE   |TRUE    => Something went wrong!!
 
     if (pending_data_) {
-      DCHECK(pending_read_size_ == 0);
+      DCHECK_EQ(pending_read_size_, 0UL);
       ReleaseBindings();
       return S_OK;
     }
 
     if (headers_received_ && pending_read_size_ == 0) {
       ReleaseBindings();
       return S_OK;
     }
 
     // No headers or there is a pending read from Chrome.
@@ skipping 223 matching lines @@
       DLOG(ERROR) << "X-Frame-Options header other than ALLOWALL " <<
           "detected, navigation canceled";
       return E_FAIL;
     }
   }
 
   DLOG(INFO) << __FUNCTION__ << me() << "Calling OnResponseStarted";
 
   // Inform the delegate.
   headers_received_ = true;
-  DCHECK(id() != -1);
+  DCHECK_NE(id(), -1);
   delegate_->OnResponseStarted(id(),
                     "",                   // mime_type
                     raw_headers.c_str(),  // headers
                     0,                    // size
                     base::Time(),         // last_modified
                     status_.get_redirection().utf8_url,
                     status_.get_redirection().http_code);
   return S_OK;
 }
 
@@ skipping 268 matching lines @@
     bool is_started = pending_request_->Start();
     DCHECK(is_started);
   }
 }
 
 void UrlmonUrlRequestManager::StartRequest(int request_id,
     const IPC::AutomationURLRequest& request_info) {
   DLOG(INFO) << __FUNCTION__ << " id: " << request_id;
   DCHECK_EQ(0, calling_delegate_);
 
-  if (stopping_)
+  if (stopping_) {
+    DLOG(WARNING) << __FUNCTION__ << " request not started (stopping)";
     return;
+  }
 
   DCHECK(request_map_.find(request_id) == request_map_.end());
   DCHECK(GURL(request_info.url).is_valid());
 
   scoped_refptr<UrlmonUrlRequest> new_request;
   bool is_started = false;
   if (pending_request_) {
     DCHECK_EQ(pending_request_->url(), request_info.url);
     new_request.swap(pending_request_);
     new_request->set_pending(false);
@@ skipping 236 matching lines @@
       privacy_info_.privacy_records[UTF8ToWide(url)];
 
   privacy_entry.flags |= flags;
   privacy_entry.policy_ref = UTF8ToWide(policy_ref);
 
   if (fire_privacy_event && IsWindow(notification_window_)) {
     PostMessage(notification_window_, WM_FIRE_PRIVACY_CHANGE_NOTIFICATION, 1,
                 0);
   }
 }