Tabs API is usable without tabs permission.

chrome/browser/extensions/extension_tab_util.cc

 // Copyright (c) 2012 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/extension_tab_util.h"
 
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
+#include "chrome/browser/extensions/event_names.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/extensions/window_controller.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_id.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_iterator.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
+#include "chrome/common/extensions/permissions/api_permission.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/favicon_status.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/web_contents.h"
 #include "googleurl/src/gurl.h"
 
 namespace keys = extensions::tabs_constants;
 
 using content::NavigationEntry;
 using content::WebContents;
 
+namespace {
+
+void StripTabOfSensitiveData(DictionaryValue* tab) {
+  tab->SetString(keys::kUrlKey, std::string());
+  tab->SetString(keys::kTitleKey, std::string());
+  tab->SetString(keys::kFaviconUrlKey, std::string());
+}
+
+}
+
 int ExtensionTabUtil::GetWindowId(const Browser* browser) {
   return browser->session_id().id();
 }
 
 int ExtensionTabUtil::GetWindowIdOfTabStripModel(
     const TabStripModel* tab_strip_model) {
   for (BrowserList::const_iterator it = BrowserList::begin();
        it != BrowserList::end(); ++it) {
     if ((*it)->tab_strip_model() == tab_strip_model)
       return GetWindowId(*it);
   }
   return -1;
 }
 
 int ExtensionTabUtil::GetTabId(const WebContents* web_contents) {
   return SessionID::IdForTab(TabContents::FromWebContents(web_contents));
 }
 
 std::string ExtensionTabUtil::GetTabStatusText(bool is_loading) {
   return is_loading ? keys::kStatusValueLoading : keys::kStatusValueComplete;
 }
 
 int ExtensionTabUtil::GetWindowIdOfTab(const WebContents* web_contents) {
   return SessionID::IdForWindowContainingTab(
       TabContents::FromWebContents(web_contents));
 }
 
-DictionaryValue* ExtensionTabUtil::CreateTabValue(const WebContents* contents) {
+DictionaryValue* ExtensionTabUtil::CreateTabValue(
+    const WebContents* contents,
+    const extensions::Extension* extension) {
   // Find the tab strip and index of this guy.
   TabStripModel* tab_strip = NULL;
   int tab_index;
-  if (ExtensionTabUtil::GetTabStripModel(contents, &tab_strip, &tab_index))
-    return ExtensionTabUtil::CreateTabValue(contents, tab_strip, tab_index);
+  if (ExtensionTabUtil::GetTabStripModel(contents, &tab_strip, &tab_index)) {
+    return ExtensionTabUtil::CreateTabValue(contents,
+                                            tab_strip,
+                                            tab_index,
+                                            extension);
+  }
 
   // Couldn't find it.  This can happen if the tab is being dragged.
-  return ExtensionTabUtil::CreateTabValue(contents, NULL, -1);
+  return ExtensionTabUtil::CreateTabValue(contents, NULL, -1, extension);
 }
 
-ListValue* ExtensionTabUtil::CreateTabList(const Browser* browser) {
+ListValue* ExtensionTabUtil::CreateTabList(
+    const Browser* browser,
+    const extensions::Extension* extension) {
   ListValue* tab_list = new ListValue();
   TabStripModel* tab_strip = browser->tab_strip_model();
   for (int i = 0; i < tab_strip->count(); ++i) {
-    tab_list->Append(ExtensionTabUtil::CreateTabValue(
-        tab_strip->GetTabContentsAt(i)->web_contents(), tab_strip, i));
+    tab_list->Append(CreateTabValue(
+        tab_strip->GetTabContentsAt(i)->web_contents(),
+        tab_strip,
+        i,
+        extension));
   }
 
   return tab_list;
 }
 
-DictionaryValue* ExtensionTabUtil::CreateTabValue(const WebContents* contents,
-                                                  TabStripModel* tab_strip,
-                                                  int tab_index) {
+DictionaryValue* ExtensionTabUtil::CreateTabValue(
+    const WebContents* contents,
+    TabStripModel* tab_strip,
+    int tab_index,
+    const extensions::Extension* extension) {
   DictionaryValue* result = new DictionaryValue();
   bool is_loading = contents->IsLoading();
-  result->SetInteger(keys::kIdKey, ExtensionTabUtil::GetTabId(contents));
+  result->SetInteger(keys::kIdKey, GetTabId(contents));
   result->SetInteger(keys::kIndexKey, tab_index);
-  result->SetInteger(keys::kWindowIdKey,
-                     ExtensionTabUtil::GetWindowIdOfTab(contents));
-  result->SetString(keys::kUrlKey, contents->GetURL().spec());
+  result->SetInteger(keys::kWindowIdKey, GetWindowIdOfTab(contents));
   result->SetString(keys::kStatusKey, GetTabStatusText(is_loading));
   result->SetBoolean(keys::kActiveKey,
                      tab_strip && tab_index == tab_strip->active_index());
   result->SetBoolean(keys::kSelectedKey,
                      tab_strip && tab_index == tab_strip->active_index());
   result->SetBoolean(keys::kHighlightedKey,
                    tab_strip && tab_strip->IsTabSelected(tab_index));
   result->SetBoolean(keys::kPinnedKey,
                      tab_strip && tab_strip->IsTabPinned(tab_index));
-  result->SetString(keys::kTitleKey, contents->GetTitle());
   result->SetBoolean(keys::kIncognitoKey,
                      contents->GetBrowserContext()->IsOffTheRecord());
 
+  // If we have an extension without permissions, we don't add sensitive data.
+  if (!extension || (extension && extension->HasAPIPermissionForTab(
+        tab_index, extensions::APIPermission::kTab))) {
+    result->SetString(keys::kUrlKey, contents->GetURL().spec());
+    result->SetString(keys::kTitleKey, contents->GetTitle());
+    if (!is_loading) {
+      NavigationEntry* entry = contents->GetController().GetActiveEntry();
+      if (entry && entry->GetFavicon().valid)
+        result->SetString(keys::kFaviconUrlKey, entry->GetFavicon().url.spec());
+    }
+  }
+
   if (tab_strip) {
     content::NavigationController* opener =
         tab_strip->GetOpenerOfTabContentsAt(tab_index);
     if (opener) {
       result->SetInteger(keys::kOpenerTabIdKey,
-                         ExtensionTabUtil::GetTabId(opener->GetWebContents()));
+                         GetTabId(opener->GetWebContents()));
     }
   }
 
-  if (!is_loading) {
-    NavigationEntry* entry = contents->GetController().GetActiveEntry();
-    if (entry) {
-      if (entry->GetFavicon().valid)
-        result->SetString(keys::kFaviconUrlKey, entry->GetFavicon().url.spec());
-    }
-  }
-
   return result;
 }
 
 DictionaryValue* ExtensionTabUtil::CreateTabValueActive(
     const WebContents* contents,
-    bool active) {
-  DictionaryValue* result = ExtensionTabUtil::CreateTabValue(contents);
+    bool active,
+    const extensions::Extension* extension) {
+  DictionaryValue* result = CreateTabValue(contents, extension);
   result->SetBoolean(keys::kSelectedKey, active);
   return result;
 }
 
+void ExtensionTabUtil::MaybeStripEventArgsOfSensitiveData(
+    const std::string& event_name,
+    const extensions::Extension* extension,
+    base::ListValue* event_args) {
+  int arg = 0;
+  if (event_name == extensions::event_names::kOnTabUpdated)
+    arg = 2;
+  else if (event_name == extensions::event_names::kOnTabUpdated)
+    arg = 0;
+  else
+    return;
+
+  if (!extension->HasAPIPermission(extensions::APIPermission::kTab)) {
+    DictionaryValue* tab;
+    event_args->GetDictionary(arg, &tab);
+    StripTabOfSensitiveData(tab);
+  }
+}
+
 bool ExtensionTabUtil::GetTabStripModel(const WebContents* web_contents,
                                         TabStripModel** tab_strip_model,
                                         int* tab_index) {
   DCHECK(web_contents);
   DCHECK(tab_strip_model);
   DCHECK(tab_index);
 
   for (BrowserList::const_iterator it = BrowserList::begin();
       it != BrowserList::end(); ++it) {
     TabStripModel* tab_strip = (*it)->tab_strip_model();
@@ skipping 10 matching lines @@
 
 bool ExtensionTabUtil::GetDefaultTab(Browser* browser,
                                      TabContents** contents,
                                      int* tab_id) {
   DCHECK(browser);
   DCHECK(contents);
 
   *contents = chrome::GetActiveTabContents(browser);
   if (*contents) {
     if (tab_id)
-      *tab_id = ExtensionTabUtil::GetTabId((*contents)->web_contents());
+      *tab_id = GetTabId((*contents)->web_contents());
     return true;
   }
 
   return false;
 }
 
 bool ExtensionTabUtil::GetTabById(int tab_id,
                                   Profile* profile,
                                   bool include_incognito,
                                   Browser** browser,
@@ skipping 89 matching lines @@
 
 // static
 extensions::WindowController* ExtensionTabUtil::GetWindowControllerOfTab(
     const WebContents* web_contents) {
   Browser* browser = browser::FindBrowserWithWebContents(web_contents);
   if (browser != NULL)
     return browser->extension_window_controller();
 
   return NULL;
 }