Add audible, muted to Tab, c.t.query, c.t.update, and c.t.onUpdated where relevant

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"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
 #include "chrome/browser/extensions/api/tabs/tabs_windows_api.h"
 #include "chrome/browser/extensions/api/tabs/windows_event_router.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_iterator.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/browser/ui/tabs/tab_utils.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "content/public/browser/favicon_status.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/web_contents.h"
 
 using base::DictionaryValue;
 using base::ListValue;
@@ skipping 22 matching lines @@
                                               properties_value);
   event_args->Set(1, properties_value);
 
   // 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() : complete_waiting_on_load_(false),
-                                        url_() {
+TabsEventRouter::TabEntry::TabEntry()
+    : contents_(NULL),
+      complete_waiting_on_load_(false),
+      was_audible_(false),
+      was_muted_(false) {
 }
 
-base::DictionaryValue* TabsEventRouter::TabEntry::UpdateLoadState(
-    const WebContents* contents) {
+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.
-  if (!complete_waiting_on_load_ || contents->IsLoading())
-    return NULL;
+  scoped_ptr<base::DictionaryValue> changed_properties(
+      new base::DictionaryValue());
+  if (!complete_waiting_on_load_ || contents_->IsLoading()) {
+    return changed_properties.Pass();
+  }
 
   // Send "complete" state change.
   complete_waiting_on_load_ = false;
-  base::DictionaryValue* changed_properties = new base::DictionaryValue();
   changed_properties->SetString(tabs_constants::kStatusKey,
                                 tabs_constants::kStatusValueComplete);
-  return changed_properties;
+  return changed_properties.Pass();
 }
 
-base::DictionaryValue* TabsEventRouter::TabEntry::DidNavigate(
-    const WebContents* contents) {
+scoped_ptr<base::DictionaryValue> TabsEventRouter::TabEntry::DidNavigate() {
   // Send "loading" state change.
   complete_waiting_on_load_ = true;
-  base::DictionaryValue* changed_properties = new base::DictionaryValue();
+  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();
+  if (contents_->GetURL() != url_) {
+    url_ = contents_->GetURL();
     changed_properties->SetString(tabs_constants::kUrlKey, url_.spec());
   }
 
-  return changed_properties;
+  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;
+  was_muted_ = new_val;
+  return true;
 }
 
 TabsEventRouter::TabsEventRouter(Profile* profile) : profile_(profile) {
   DCHECK(!profile->IsOffTheRecord());
 
   BrowserList::AddObserver(this);
 
   // Init() can happen after the browser is running, so catch up with any
   // windows that already exist.
   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
     RegisterForBrowserNotifications(*it);
 
     // Also catch up our internal bookkeeping of tab entries.
     Browser* browser = *it;
     if (browser->tab_strip_model()) {
       for (int i = 0; i < browser->tab_strip_model()->count(); ++i) {
         WebContents* contents = browser->tab_strip_model()->GetWebContentsAt(i);
         int tab_id = ExtensionTabUtil::GetTabId(contents);
-        tab_entries_[tab_id] = TabEntry();
+        tab_entries_[tab_id] = TabEntry(contents);
       }
     }
   }
 }
 
 TabsEventRouter::~TabsEventRouter() {
   BrowserList::RemoveObserver(this);
 }
 
 void TabsEventRouter::OnBrowserAdded(Browser* browser) {
@@ skipping 84 matching lines @@
 
   RegisterForTabNotifications(contents);
 }
 
 void TabsEventRouter::TabInsertedAt(WebContents* contents,
                                     int index,
                                     bool active) {
   // If tab is new, send created event.
   int tab_id = ExtensionTabUtil::GetTabId(contents);
   if (!GetTabEntry(contents)) {
-    tab_entries_[tab_id] = TabEntry();
+    tab_entries_[tab_id] = TabEntry(contents);
 
     TabCreatedAt(contents, index, active);
     return;
   }
 
   scoped_ptr<base::ListValue> args(new base::ListValue);
   args->Append(new FundamentalValue(tab_id));
 
   base::DictionaryValue* object_args = new base::DictionaryValue();
   object_args->Set(tabs_constants::kNewWindowIdKey,
@@ skipping 154 matching lines @@
                    new FundamentalValue(to_index));
   args->Append(object_args);
 
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   DispatchEvent(profile,
                 tabs::OnMoved::kEventName,
                 args.Pass(),
                 EventRouter::USER_GESTURE_UNKNOWN);
 }
 
-void TabsEventRouter::TabUpdated(WebContents* contents, bool did_navigate) {
-  TabEntry* entry = GetTabEntry(contents);
-  scoped_ptr<base::DictionaryValue> changed_properties;
+void TabsEventRouter::TabUpdated(
+    TabsEventRouter::TabEntry* entry,
+    scoped_ptr<base::DictionaryValue> changed_properties) {
+  CHECK(entry->web_contents());
 
-  CHECK(entry);
+  const char* muteSwitch = switches::kEnableTabAudioMuting;

[not at google - send to devlin, 2015/06/01 20:33:56]

I don't think this alias is necessary, though for the record (and if you really
need it) then it should be mute_switch not muteSwitch.

[Jared Sohn, 2015/06/02 08:54:38]

Oversight; removed.

On 2015/06/01 at 20:33:56, kalman wrote:

+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(muteSwitch)) {
+    bool audible = entry->web_contents()->WasRecentlyAudible();
+    if (entry->SetAudible(audible)) {
+      changed_properties->SetBoolean(tabs_constants::kAudibleKey, audible);
+    }
 
-  if (did_navigate)
-    changed_properties.reset(entry->DidNavigate(contents));
-  else
-    changed_properties.reset(entry->UpdateLoadState(contents));
+    bool muted = entry->web_contents()->IsAudioMuted();
+    if (entry->SetMuted(muted)) {
+      changed_properties->SetBoolean(tabs_constants::kMutedKey, muted);
+      changed_properties->SetString(
+          tabs_constants::kMutedCauseKey,
+          chrome::GetTabAudioMutedCause(entry->web_contents()));
+    }
+  }
 
-  if (changed_properties)
-    DispatchTabUpdatedEvent(contents, changed_properties.Pass());
+  if (!changed_properties->empty()) {
+    DispatchTabUpdatedEvent(entry->web_contents(), changed_properties.Pass());
+  }
 }
 
 void TabsEventRouter::FaviconUrlUpdated(WebContents* contents) {
     content::NavigationEntry* entry =
         contents->GetController().GetVisibleEntry();
     if (!entry || !entry->GetFavicon().valid)
       return;
     scoped_ptr<base::DictionaryValue> changed_properties(
         new base::DictionaryValue);
     changed_properties->SetString(
@@ skipping 70 matching lines @@
     return NULL;
   return &i->second;
 }
 
 void TabsEventRouter::Observe(int type,
                               const content::NotificationSource& source,
                               const content::NotificationDetails& details) {
   if (type == content::NOTIFICATION_NAV_ENTRY_COMMITTED) {
     NavigationController* source_controller =
         content::Source<NavigationController>(source).ptr();
-    TabUpdated(source_controller->GetWebContents(), true);
+    TabEntry* entry = GetTabEntry(source_controller->GetWebContents());
+    CHECK(entry);
+    TabUpdated(entry, entry->DidNavigate());
   } else if (type == 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));
     registrar_.Remove(this, chrome::NOTIFICATION_FAVICON_UPDATED,
         content::Source<WebContents>(contents));
   } else if (type == chrome::NOTIFICATION_FAVICON_UPDATED) {
     bool icon_url_changed = *content::Details<bool>(details).ptr();
     if (icon_url_changed)
       FaviconUrlUpdated(content::Source<WebContents>(source).ptr());
   } else {
     NOTREACHED();
   }
 }
 
 void TabsEventRouter::TabChangedAt(WebContents* contents,
                                    int index,
                                    TabChangeType change_type) {
-  TabUpdated(contents, false);
+  TabEntry* entry = GetTabEntry(contents);
+  CHECK(entry);
+  TabUpdated(entry, entry->UpdateLoadState());
 }
 
 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);
   scoped_ptr<base::ListValue> args(new base::ListValue);
   args->Append(new FundamentalValue(new_tab_id));
   args->Append(new FundamentalValue(old_tab_id));
 
   DispatchEvent(Profile::FromBrowserContext(new_contents->GetBrowserContext()),
                 tabs::OnReplaced::kEventName,
                 args.Pass(),
                 EventRouter::USER_GESTURE_UNKNOWN);
 
   // Update tab_entries_.
   const int removed_count = tab_entries_.erase(old_tab_id);
   DCHECK_GT(removed_count, 0);
   UnregisterForTabNotifications(old_contents);
 
   if (!GetTabEntry(new_contents)) {
-    tab_entries_[new_tab_id] = TabEntry();
+    tab_entries_[new_tab_id] = TabEntry(new_contents);
     RegisterForTabNotifications(new_contents);
   }
 }
 
 void TabsEventRouter::TabPinnedStateChanged(WebContents* contents, int index) {
   TabStripModel* tab_strip = NULL;
   int tab_index;
 
   if (ExtensionTabUtil::GetTabStripModel(contents, &tab_strip, &tab_index)) {
     scoped_ptr<base::DictionaryValue> changed_properties(
@@ skipping 24 matching lines @@
   // Dispatch the |onZoomChange| event.
   Profile* profile = Profile::FromBrowserContext(
       data.web_contents->GetBrowserContext());
   DispatchEvent(profile,
                 tabs::OnZoomChange::kEventName,
                 api::tabs::OnZoomChange::Create(zoom_change_info),
                 EventRouter::USER_GESTURE_UNKNOWN);
 }
 
 }  // namespace extensions