Tabs API is usable without tabs permission.

chrome/browser/extensions/api/tabs/tabs.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/api/tabs/tabs.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
@@ skipping 801 matching lines @@
   Browser* browser = NULL;
   if (!GetBrowserFromWindowID(this, window_id, &browser))
     return false;
 
   TabStripModel* tab_strip = browser->tab_strip_model();
   TabContents* contents = tab_strip->GetActiveTabContents();
   if (!contents) {
     error_ = keys::kNoSelectedTabError;
     return false;
   }
-  SetResult(ExtensionTabUtil::CreateTabValue(contents->web_contents(),
-                                             tab_strip,
-                                             tab_strip->active_index()));
+  DictionaryValue* result = ExtensionTabUtil::CreateTabValue(

[Aaron Boodman, 2012/08/10 06:44:51]

Can we pass Extension* into CreateTabValue and let it decide whether to add the
sensitive data.

That way people can't forget to do this check.

Or maybe this function is used places we don't want to have this behavior?

[chebert, 2012/08/13 23:52:17]

An overloaded version is called from the MenuManager, the BrowserEventRouter,
and the MessageService.

I can make another overload that takes either the Extension* or a bool for
permissions, but I think that would be confusing.

Maybe a function name that describes that it is supposed to be used by the API
functions like CreateTabValueForExtension()?
CreateTabValueForAPIResult()?
CreateTabResultValue()?

On 2012/08/10 06:44:51, Aaron Boodman wrote:

+      contents->web_contents(),
+      tab_strip,
+      tab_strip->active_index());
+  if (!GetExtension()->HasAPIPermission(extensions::APIPermission::kTab))
+    ExtensionTabUtil::StripTabOfSensitiveData(result);
+  SetResult(result);
   return true;
 }
 
 bool GetAllTabsInWindowFunction::RunImpl() {
   // windowId defaults to "current" window.
   int window_id = extension_misc::kCurrentWindowId;
   if (HasOptionalArgument(0))
     EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &window_id));
 
   Browser* browser = NULL;
@@ skipping 103 matching lines @@
       if (!title.empty() && !MatchPattern(web_contents->GetTitle(),
                                           UTF8ToUTF16(title)))
         continue;
 
       if (!url_pattern.MatchesURL(web_contents->GetURL()))
         continue;
 
       if (!MatchesQueryArg(loading, web_contents->IsLoading()))
         continue;
 
-      result->Append(ExtensionTabUtil::CreateTabValue(
-          web_contents, tab_strip, i));
+      DictionaryValue* tab = ExtensionTabUtil::CreateTabValue(
+          web_contents, tab_strip, i);
+      if (!GetExtension()->HasAPIPermission(extensions::APIPermission::kTab))
+        ExtensionTabUtil::StripTabOfSensitiveData(tab);
+      result->Append(tab);
     }
   }
 
   SetResult(result);
   return true;
 }
 
 bool CreateTabFunction::RunImpl() {
   DictionaryValue* args = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
@@ skipping 114 matching lines @@
   tab_strip = params.browser->tab_strip_model();
   int new_index = tab_strip->GetIndexOfTabContents(params.target_contents);
   if (opener)
     tab_strip->SetOpenerOfTabContentsAt(new_index, opener);
 
   if (active)
     params.target_contents->web_contents()->GetView()->SetInitialFocus();
 
   // Return data about the newly created tab.
   if (has_callback()) {
-    SetResult(ExtensionTabUtil::CreateTabValue(
+    DictionaryValue* result = ExtensionTabUtil::CreateTabValue(
         params.target_contents->web_contents(),
-        tab_strip, new_index));
+        tab_strip, new_index);
+    if (!GetExtension()->HasAPIPermission(extensions::APIPermission::kTab))
+      ExtensionTabUtil::StripTabOfSensitiveData(result);
+    SetResult(result);
   }
 
   return true;
 }
 
 bool GetTabFunction::RunImpl() {
   int tab_id = -1;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id));
 
   TabStripModel* tab_strip = NULL;
   TabContents* contents = NULL;
   int tab_index = -1;
   if (!GetTabById(tab_id, profile(), include_incognito(),
                   NULL, &tab_strip, &contents, &tab_index, &error_))
     return false;
 
-  SetResult(ExtensionTabUtil::CreateTabValue(contents->web_contents(),
-                                             tab_strip,
-                                             tab_index));
+  DictionaryValue* result = ExtensionTabUtil::CreateTabValue(
+      contents->web_contents(),
+      tab_strip,
+      tab_index);
+  if (!GetExtension()->HasAPIPermission(extensions::APIPermission::kTab))
+    ExtensionTabUtil::StripTabOfSensitiveData(result);
+  SetResult(result);
   return true;
 }
 
 bool GetCurrentTabFunction::RunImpl() {
   DCHECK(dispatcher());
 
   WebContents* contents = dispatcher()->delegate()->GetAssociatedWebContents();
-  if (contents)
-    SetResult(ExtensionTabUtil::CreateTabValue(contents));
+  if (contents) {
+    DictionaryValue* result = ExtensionTabUtil::CreateTabValue(contents);
+    if (!GetExtension()->HasAPIPermission(extensions::APIPermission::kTab))
+      ExtensionTabUtil::StripTabOfSensitiveData(result);
+    SetResult(result);
+  }
 
   return true;
 }
 
 bool HighlightTabsFunction::RunImpl() {
   DictionaryValue* info = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &info));
 
   // Get the window id from the params; default to current window if omitted.
   int window_id = extension_misc::kCurrentWindowId;
@@ skipping 208 matching lines @@
   if (!url.SchemeIs(chrome::kJavaScriptScheme))
     DCHECK_EQ(url.spec(), tab_contents_->web_contents()->GetURL().spec());
 
   return true;
 }
 
 void UpdateTabFunction::PopulateResult() {
   if (!has_callback())
     return;
 
-  if (GetExtension()->HasAPIPermission(extensions::APIPermission::kTab)) {
-    SetResult(ExtensionTabUtil::CreateTabValue(tab_contents_->web_contents()));
-  } else {
-    SetResult(Value::CreateNullValue());
-  }
+  DictionaryValue* result = ExtensionTabUtil::CreateTabValue(
+      tab_contents_->web_contents());
+  if (!GetExtension()->HasAPIPermission(extensions::APIPermission::kTab))
+    ExtensionTabUtil::StripTabOfSensitiveData(result);
+  SetResult(result);
 }
 
 void UpdateTabFunction::OnExecuteCodeFinished(bool success,
                                               int32 page_id,
                                               const std::string& error,
                                               const ListValue& script_result) {
   if (!error.empty()) {
     CHECK(!success);
     error_ = error;
   }
@@ skipping 74 matching lines @@
 
         // Clamp move location to the last position.
         // This is ">" because it can append to a new index position.
         // -1 means set the move location to the last position.
         if (new_index > target_tab_strip->count() || new_index < 0)
           new_index = target_tab_strip->count();
 
         target_tab_strip->InsertTabContentsAt(
             new_index, contents, TabStripModel::ADD_NONE);
 
-        if (has_callback())
-          tab_values.Append(ExtensionTabUtil::CreateTabValue(
-              contents->web_contents(), target_tab_strip, new_index));
+        if (has_callback()) {
+          DictionaryValue* result = ExtensionTabUtil::CreateTabValue(
+              contents->web_contents(), target_tab_strip, new_index);
+          if (!GetExtension()->HasAPIPermission(
+                extensions::APIPermission::kTab)) {
+            ExtensionTabUtil::StripTabOfSensitiveData(result);
+          }
+          tab_values.Append(result);
+        }
 
         continue;
       }
     }
 
     // Perform a simple within-window move.
     // Clamp move location to the last position.
     // This is ">=" because the move must be to an existing location.
     // -1 means set the move location to the last position.
     if (new_index >= source_tab_strip->count() || new_index < 0)
       new_index = source_tab_strip->count() - 1;
 
     if (new_index != tab_index)
       source_tab_strip->MoveTabContentsAt(tab_index, new_index, false);
 
-    if (has_callback())
-      tab_values.Append(ExtensionTabUtil::CreateTabValue(
-          contents->web_contents(), source_tab_strip, new_index));
+    if (has_callback()) {
+      DictionaryValue* result = ExtensionTabUtil::CreateTabValue(
+          contents->web_contents(), source_tab_strip, new_index);
+      if (!GetExtension()->HasAPIPermission(extensions::APIPermission::kTab))
+        ExtensionTabUtil::StripTabOfSensitiveData(result);
+      tab_values.Append(result);
+    }
   }
 
   if (!has_callback())
     return true;
 
   // Only return the results as an array if there are multiple tabs.
   if (tab_ids.size() > 1) {
     SetResult(tab_values.DeepCopy());
   } else if (tab_ids.size() == 1) {
     Value* value = NULL;
@@ skipping 350 matching lines @@
   // called for every API call the extension made.
   GotLanguage(language);
 }
 
 void DetectTabLanguageFunction::GotLanguage(const std::string& language) {
   SetResult(Value::CreateStringValue(language.c_str()));
   SendResponse(true);
 
   Release();  // Balanced in Run()
 }