chrome.tabs.onUpdated doesn't called with 'loading' twice.

chrome/browser/extensions/api/tabs/tabs_event_router.cc

 // Copyright 2013 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/extensions/api/tabs/tabs_event_router.h"
 
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 46 matching lines @@
 
   // Overwrite the third arg with our tab value as seen by this extension.
   event_args->Set(2, ExtensionTabUtil::CreateTabValue(contents, extension));
   return true;
 }
 
 }  // namespace
 
 TabsEventRouter::TabEntry::TabEntry(content::WebContents* contents)
     : contents_(contents),
-      complete_waiting_on_load_(false),
       was_audible_(contents->WasRecentlyAudible()),
       was_muted_(contents->IsAudioMuted()) {
 }
 
-scoped_ptr<base::DictionaryValue> TabsEventRouter::TabEntry::UpdateLoadState() {
-  // The tab may go in & out of loading (for instance if iframes navigate).
-  // We only want to respond to the first change from loading to !loading after
-  // the NAV_ENTRY_COMMITTED was fired.
+scoped_ptr<base::DictionaryValue> TabsEventRouter::TabEntry::Update() {
   scoped_ptr<base::DictionaryValue> changed_properties(
       new base::DictionaryValue());
-  if (!complete_waiting_on_load_ || contents_->IsLoading()) {
-    return changed_properties.Pass();
+  if (status_ != "loading" && contents_->IsLoading() &&
+      contents_->GetLastCommittedURL() != url_) {
+    changed_properties->SetString(tabs_constants::kStatusKey,
+                                  tabs_constants::kStatusValueLoading);
+    status_ = "loading";
+  } else if (status_ == "loading" && !contents_->IsLoading()) {
+    changed_properties->SetString(tabs_constants::kStatusKey,
+                                  tabs_constants::kStatusValueComplete);
+    status_ = "complete";
   }
 
-  // Send "complete" state change.
-  complete_waiting_on_load_ = false;
-  changed_properties->SetString(tabs_constants::kStatusKey,
-                                tabs_constants::kStatusValueComplete);
+  if (contents_->GetLastCommittedURL() != url_) {
+    url_ = contents_->GetLastCommittedURL();
+    changed_properties->SetString(tabs_constants::kUrlKey, url_.spec());
+  }
   return changed_properties.Pass();
 }
 
-scoped_ptr<base::DictionaryValue> TabsEventRouter::TabEntry::DidNavigate() {
-  // Send "loading" state change.
-  complete_waiting_on_load_ = true;
-  scoped_ptr<base::DictionaryValue> changed_properties(
-      new base::DictionaryValue());
-  changed_properties->SetString(tabs_constants::kStatusKey,
-                                tabs_constants::kStatusValueLoading);
-
-  if (contents_->GetURL() != url_) {
-    url_ = contents_->GetURL();
-    changed_properties->SetString(tabs_constants::kUrlKey, url_.spec());
-  }
-
-  return changed_properties.Pass();
-}
-
 bool TabsEventRouter::TabEntry::SetAudible(bool new_val) {
   if (was_audible_ == new_val)
     return false;
   was_audible_ = new_val;
   return true;
 }
 
 bool TabsEventRouter::TabEntry::SetMuted(bool new_val) {
   if (was_muted_ == new_val)
     return false;
@@ skipping 38 matching lines @@
   // Start listening to TabStripModel events for this browser.
   TabStripModel* tab_strip = browser->tab_strip_model();
   tab_strip->AddObserver(this);
 
   for (int i = 0; i < tab_strip->count(); ++i) {
     RegisterForTabNotifications(tab_strip->GetWebContentsAt(i));
   }
 }
 
 void TabsEventRouter::RegisterForTabNotifications(WebContents* contents) {
+  // TODO(limasdf): Attach WebContentsObservers to |contents| rather than
+  // registering for notifications.
   registrar_.Add(
       this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
       content::Source<NavigationController>(&contents->GetController()));
 
   // Observing NOTIFICATION_WEB_CONTENTS_DESTROYED is necessary because it's
   // possible for tabs to be created, detached and then destroyed without
   // ever having been re-attached and closed. This happens in the case of
   // a devtools WebContents that is opened in window, docked, then closed.
   registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
                  content::Source<WebContents>(contents));
@@ skipping 326 matching lines @@
 
   TabEntryMap::iterator i = tab_entries_.find(tab_id);
   if (tab_entries_.end() == i)
     return linked_ptr<TabEntry>(NULL);
   return i->second;
 }
 
 void TabsEventRouter::Observe(int type,
                               const content::NotificationSource& source,
                               const content::NotificationDetails& details) {
-  if (type == content::NOTIFICATION_NAV_ENTRY_COMMITTED) {
+  switch (type) {
+    case content::NOTIFICATION_NAV_ENTRY_COMMITTED: {
     NavigationController* source_controller =
         content::Source<NavigationController>(source).ptr();
     linked_ptr<TabEntry> entry =
         GetTabEntry(source_controller->GetWebContents());
     CHECK(entry.get());
-    TabUpdated(entry, (entry.get())->DidNavigate());
-  } else if (type == content::NOTIFICATION_WEB_CONTENTS_DESTROYED) {
+    TabUpdated(entry, (entry.get())->Update());
+    }
+    case content::NOTIFICATION_WEB_CONTENTS_DESTROYED: {
     // Tab was destroyed after being detached (without being re-attached).
     WebContents* contents = content::Source<WebContents>(source).ptr();
     registrar_.Remove(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
         content::Source<NavigationController>(&contents->GetController()));
     registrar_.Remove(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
         content::Source<WebContents>(contents));
     favicon_scoped_observer_.Remove(
         favicon::ContentFaviconDriver::FromWebContents(contents));
-  } else {
-    NOTREACHED();
+    }
+    default:
+      NOTREACHED();
   }
 }
 
 void TabsEventRouter::TabChangedAt(WebContents* contents,
                                    int index,
                                    TabChangeType change_type) {
   linked_ptr<TabEntry> entry = GetTabEntry(contents);
   CHECK(entry.get());
-  TabUpdated(entry, (entry.get())->UpdateLoadState());
+  TabUpdated(entry, (entry.get())->Update());
 }
 
 void TabsEventRouter::TabReplacedAt(TabStripModel* tab_strip_model,
                                     WebContents* old_contents,
                                     WebContents* new_contents,
                                     int index) {
   // Notify listeners that the next tabs closing or being added are due to
   // WebContents being swapped.
   const int new_tab_id = ExtensionTabUtil::GetTabId(new_contents);
   const int old_tab_id = ExtensionTabUtil::GetTabId(old_contents);
@@ skipping 61 matching lines @@
 void TabsEventRouter::OnFaviconUpdated(favicon::FaviconDriver* favicon_driver,
                                        bool icon_url_changed) {
   if (icon_url_changed) {
     favicon::ContentFaviconDriver* content_favicon_driver =
         static_cast<favicon::ContentFaviconDriver*>(favicon_driver);
     FaviconUrlUpdated(content_favicon_driver->web_contents());
   }
 }
 
 }  // namespace extensions