Wait properly for renderer crashes

chrome/browser/automation/automation_provider_observers.cc

 // Copyright (c) 2011 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/browser/automation/automation_provider_observers.h"
 
 #include <deque>
 #include <string>
 #include <vector>
 
@@ skipping 81 matching lines @@
     return load_start_time_;
   }
  private:
   base::TimeTicks load_start_time_;
   base::TimeTicks load_stop_time_;
 };
 
 InitialLoadObserver::InitialLoadObserver(size_t tab_count,
                                          AutomationProvider* automation)
     : automation_(automation->AsWeakPtr()),
+      crashed_tab_count_(0),
       outstanding_tab_count_(tab_count),
       init_time_(base::TimeTicks::Now()) {
   if (outstanding_tab_count_ > 0) {
     registrar_.Add(this, content::NOTIFICATION_LOAD_START,
                    NotificationService::AllSources());
     registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
                    NotificationService::AllSources());
+    registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CREATED,
+                   NotificationService::AllSources());
+    registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
+                   NotificationService::AllSources());
   }
 }
 
 InitialLoadObserver::~InitialLoadObserver() {
 }
 
 void InitialLoadObserver::Observe(int type,
                                   const NotificationSource& source,
                                   const NotificationDetails& details) {
   if (type == content::NOTIFICATION_LOAD_START) {
     if (outstanding_tab_count_ > loading_tabs_.size())
       loading_tabs_.insert(TabTimeMap::value_type(
           source.map_key(),
           TabTime(base::TimeTicks::Now())));
   } else if (type == content::NOTIFICATION_LOAD_STOP) {
     if (outstanding_tab_count_ > finished_tabs_.size()) {
       TabTimeMap::iterator iter = loading_tabs_.find(source.map_key());
       if (iter != loading_tabs_.end()) {
         finished_tabs_.insert(source.map_key());
         iter->second.set_stop_time(base::TimeTicks::Now());
       }
-      if (outstanding_tab_count_ == finished_tabs_.size())
-        ConditionMet();
     }
+  } else if (type == content::NOTIFICATION_RENDERER_PROCESS_CREATED) {
+    LOG(INFO) << "Got RENDERER_PROCESS_CREATED";
+  } else if (type == content::NOTIFICATION_RENDERER_PROCESS_CLOSED) {
+    LOG(INFO) << "Got RENDERER_PROCESS_CLOSED";
+
+    // Assume no render process transitions on initial loads for simplicity.
+    // Treat every closing render process as a crash.

[darin (slow to review), 2011/09/15 05:43:37]

It might help to explain why instead of just summarizing what the code does. 
Why do you want to map the closed notification to crashes?  How do you know that
it will always mean that a renderer crashed?

[Paweł Hajdan Jr., 2011/09/15 18:36:44]

I just removed that assumption then. Probably better to fix than to explain.

+    crashed_tab_count_++;
   } else {
     NOTREACHED();
   }
+
+  if (finished_tabs_.size() + crashed_tab_count_ >= outstanding_tab_count_)
+    ConditionMet();
 }
 
 DictionaryValue* InitialLoadObserver::GetTimingInformation() const {
   ListValue* items = new ListValue;
   for (TabTimeMap::const_iterator it = loading_tabs_.begin();
        it != loading_tabs_.end();
        ++it) {
     DictionaryValue* item = new DictionaryValue;
     base::TimeDelta delta_start = it->second.start_time() - init_time_;
 
@@ skipping 2554 matching lines @@
 void DragTargetDropAckNotificationObserver::Observe(
     int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   if (automation_) {
     AutomationJSONReply(automation_,
                         reply_message_.release()).SendSuccess(NULL);
   }
   delete this;
 }