Revert 49862 - Measure loading time of several tabs....

chrome/browser/automation/automation_provider_observers.cc

 // Copyright (c) 2009 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 "base/basictypes.h"
 #include "base/json/json_writer.h"
 #include "base/string_util.h"
 #include "chrome/app/chrome_dll_resource.h"
@@ skipping 10 matching lines @@
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/test/automation/automation_constants.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/authentication_notification_details.h"
 #endif
 
-// Holds onto start and stop timestamps for a particular tab
-class InitialLoadObserver::TabTime {
- public:
-  explicit TabTime(base::TimeTicks started)
-      : load_start_time_(started) {
-  }
-  void set_stop_time(base::TimeTicks stopped) {
-    load_stop_time_ = stopped;
-  }
-  base::TimeTicks stop_time() const {
-    return load_stop_time_;
-  }
-  base::TimeTicks start_time() const {
-    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),
-      outstanding_tab_count_(tab_count),
-      init_time_(base::TimeTicks::Now()) {
+      outstanding_tab_count_(tab_count) {
   if (outstanding_tab_count_ > 0) {
     registrar_.Add(this, NotificationType::LOAD_START,
                    NotificationService::AllSources());
     registrar_.Add(this, NotificationType::LOAD_STOP,
                    NotificationService::AllSources());
   }
 }
 
 InitialLoadObserver::~InitialLoadObserver() {
 }
 
 void InitialLoadObserver::Observe(NotificationType type,
                                   const NotificationSource& source,
                                   const NotificationDetails& details) {
   if (type == NotificationType::LOAD_START) {
     if (outstanding_tab_count_ > loading_tabs_.size())
-      loading_tabs_.insert(TabTimeMap::value_type(
-          source.map_key(),
-          TabTime(base::TimeTicks::Now())));
+      loading_tabs_.insert(source.map_key());
   } else if (type == NotificationType::LOAD_STOP) {
     if (outstanding_tab_count_ > finished_tabs_.size()) {
-      TabTimeMap::iterator iter = loading_tabs_.find(source.map_key());
-      if (iter != loading_tabs_.end()) {
+      if (loading_tabs_.find(source.map_key()) != 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 {
     NOTREACHED();
   }
 }
 
-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_;
-
-    item->SetReal(L"load_start_ms", delta_start.InMillisecondsF());
-    if (it->second.stop_time().is_null()) {
-      item->Set(L"load_stop_ms", Value::CreateNullValue());
-    } else {
-      base::TimeDelta delta_stop = it->second.stop_time() - init_time_;
-      item->SetReal(L"load_stop_ms", delta_stop.InMillisecondsF());
-    }
-    items->Append(item);
-  }
-  DictionaryValue* return_value = new DictionaryValue;
-  return_value->Set(L"tabs", items);
-  return return_value;
-}
-
 void InitialLoadObserver::ConditionMet() {
   registrar_.RemoveAll();
   automation_->Send(new AutomationMsg_InitialLoadsComplete(0));
 }
 
 NewTabUILoadObserver::NewTabUILoadObserver(AutomationProvider* automation)
     : automation_(automation) {
   registrar_.Add(this, NotificationType::INITIAL_NEW_TAB_UI_LOAD,
                  NotificationService::AllSources());
 }
@@ skipping 913 matching lines @@
       type == NotificationType::AUTH_NEEDED) {
     AutomationMsg_SendJSONRequest::WriteReplyParams(
         reply_message_, std::string("{}"), false);
     automation_->Send(reply_message_);
     delete this;
   } else {
     NOTREACHED();
   }
 }