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 246 matching lines @@
 
   bool populate_tabs = false;
   if (params->get_info.get() && params->get_info->populate.get())
     populate_tabs = *params->get_info->populate;
 
   WindowController* controller;
   if (!GetWindowFromWindowID(this, params->window_id, &controller))
     return false;
 
   if (populate_tabs)
-    SetResult(controller->CreateWindowValueWithTabs());
+    SetResult(controller->CreateWindowValueWithTabs(GetExtension()));
   else
     SetResult(controller->CreateWindowValue());
   return true;
 }
 
 bool GetCurrentWindowFunction::RunImpl() {
   scoped_ptr<GetCurrent::Params> params(GetCurrent::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool populate_tabs = false;
   if (params->get_info.get() && params->get_info->populate.get())
     populate_tabs = *params->get_info->populate;
 
   WindowController* controller;
   if (!GetWindowFromWindowID(this,
                              extension_misc::kCurrentWindowId,
                              &controller)) {
     return false;
   }
   if (populate_tabs)
-    SetResult(controller->CreateWindowValueWithTabs());
+    SetResult(controller->CreateWindowValueWithTabs(GetExtension()));
   else
     SetResult(controller->CreateWindowValue());
   return true;
 }
 
 bool GetLastFocusedWindowFunction::RunImpl() {
   scoped_ptr<GetLastFocused::Params> params(
       GetLastFocused::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool populate_tabs = false;
   if (params->get_info.get() && params->get_info->populate.get())
     populate_tabs = *params->get_info->populate;
 
   // Note: currently this returns the last active browser. If we decide to
   // include other window types (e.g. panels), we will need to add logic to
   // WindowControllerList that mirrors the active behavior of BrowserList.
   Browser* browser = browser::FindAnyBrowser(
       profile(), include_incognito());
   if (!browser || !browser->window()) {
     error_ = keys::kNoLastFocusedWindowError;
     return false;
   }
   WindowController* controller =
       browser->extension_window_controller();
   if (populate_tabs)
-    SetResult(controller->CreateWindowValueWithTabs());
+    SetResult(controller->CreateWindowValueWithTabs(GetExtension()));
   else
     SetResult(controller->CreateWindowValue());
   return true;
 }
 
 bool GetAllWindowsFunction::RunImpl() {
   scoped_ptr<GetAll::Params> params(GetAll::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool populate_tabs = false;
   if (params->get_info.get() && params->get_info->populate.get())
     populate_tabs = *params->get_info->populate;
 
   ListValue* window_list = new ListValue();
   const WindowControllerList::ControllerList& windows =
       WindowControllerList::GetInstance()->windows();
   for (WindowControllerList::ControllerList::const_iterator iter =
            windows.begin();
        iter != windows.end(); ++iter) {
     if (!this->CanOperateOnWindow(*iter))
       continue;
     if (populate_tabs)
-      window_list->Append((*iter)->CreateWindowValueWithTabs());
+      window_list->Append((*iter)->CreateWindowValueWithTabs(GetExtension()));
     else
       window_list->Append((*iter)->CreateWindowValue());
   }
   SetResult(window_list);
   return true;
 }
 
 bool CreateWindowFunction::ShouldOpenIncognitoWindow(
     const base::DictionaryValue* args,
     std::vector<GURL>* urls,
@@ skipping 231 matching lines @@
       Panel* panel = PanelManager::GetInstance()->CreatePanel(
           title, window_profile, urls[0], panel_bounds.size());
 
       // Unlike other window types, Panels do not take focus by default.
       if (!saw_focus_key || !focused)
         panel->ShowInactive();
       else
         panel->Show();
 
     SetResult(
-        panel->extension_window_controller()->CreateWindowValueWithTabs());
+        panel->extension_window_controller()->CreateWindowValueWithTabs(
+            GetExtension()));
     return true;
   }
 #endif
     // else fall through to create BrowserWindow
   }
 
   // Create a new BrowserWindow.
   Browser::CreateParams create_params(window_type, window_profile);
   if (extension_id.empty()) {
     create_params.initial_bounds = window_bounds;
@@ skipping 31 matching lines @@
   if (focused)
     new_window->window()->Show();
   else
     new_window->window()->ShowInactive();
 
   if (new_window->profile()->IsOffTheRecord() && !include_incognito()) {
     // Don't expose incognito windows if the extension isn't allowed.
     SetResult(Value::CreateNullValue());
   } else {
     SetResult(
-        new_window->extension_window_controller()->CreateWindowValueWithTabs());
+        new_window->extension_window_controller()->CreateWindowValueWithTabs(
+            GetExtension()));
   }
 
   return true;
 }
 
 bool UpdateWindowFunction::RunImpl() {
   int window_id = extension_misc::kUnknownWindowId;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &window_id));
   DictionaryValue* update_props;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &update_props));
@@ skipping 160 matching lines @@
     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()));
+                                             tab_strip->active_index(),
+                                             GetExtension()));
   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;
   if (!GetBrowserFromWindowID(this, window_id, &browser))
     return false;
 
-  SetResult(ExtensionTabUtil::CreateTabList(browser));
+  SetResult(ExtensionTabUtil::CreateTabList(browser, GetExtension()));
 
   return true;
 }
 
 bool QueryTabsFunction::RunImpl() {
   DictionaryValue* query = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &query));
 
   QueryArg active = ParseBoolQueryArg(query, keys::kActiveKey);
   QueryArg pinned = ParseBoolQueryArg(query, keys::kPinnedKey);
@@ skipping 90 matching lines @@
                                           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));
+          web_contents, tab_strip, i, GetExtension()));
     }
   }
 
   SetResult(result);
   return true;
 }
 
 bool CreateTabFunction::RunImpl() {
   DictionaryValue* args = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
@@ skipping 116 matching lines @@
   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(
         params.target_contents->web_contents(),
-        tab_strip, new_index));
+        tab_strip, new_index, GetExtension()));
   }
 
   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));
+                                             tab_index,
+                                             GetExtension()));
   return true;
 }
 
 bool GetCurrentTabFunction::RunImpl() {
   DCHECK(dispatcher());
 
   WebContents* contents = dispatcher()->delegate()->GetAssociatedWebContents();
   if (contents)
-    SetResult(ExtensionTabUtil::CreateTabValue(contents));
+    SetResult(ExtensionTabUtil::CreateTabValue(contents, GetExtension()));
 
   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 36 matching lines @@
 
   // Make sure they actually specified tabs to select.
   if (selection.empty()) {
     error_ = keys::kNoHighlightedTabError;
     return false;
   }
 
   selection.set_active(active_index);
   browser->tab_strip_model()->SetSelectionFromModel(selection);
   SetResult(
-      browser->extension_window_controller()->CreateWindowValueWithTabs());
+      browser->extension_window_controller()->CreateWindowValueWithTabs(
+          GetExtension()));
   return true;
 }
 
 UpdateTabFunction::UpdateTabFunction() : tab_contents_(NULL) {
 }
 
 bool UpdateTabFunction::RunImpl() {
   DictionaryValue* update_props = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &update_props));
 
@@ skipping 155 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());
-  }
+  SetResult(ExtensionTabUtil::CreateTabValue(tab_contents_->web_contents(),
+                                             GetExtension()));
 }
 
 void UpdateTabFunction::OnExecuteCodeFinished(const std::string& error,
                                               int32 on_page_id,
                                               const GURL& url,
                                               const ListValue& script_result) {
   if (error.empty())
     PopulateResult();
   else
     error_ = error;
@@ skipping 71 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())
+        if (has_callback()) {
           tab_values.Append(ExtensionTabUtil::CreateTabValue(
-              contents->web_contents(), target_tab_strip, new_index));
+              contents->web_contents(),
+              target_tab_strip,
+              new_index,
+              GetExtension()));
+        }
 
         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())
+    if (has_callback()) {
       tab_values.Append(ExtensionTabUtil::CreateTabValue(
-          contents->web_contents(), source_tab_strip, new_index));
+          contents->web_contents(), source_tab_strip, new_index,
+          GetExtension()));
+    }
   }
 
   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()
 }