Added support for multiple parameters to Extension API callbacks.

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 243 matching lines @@
 
   bool populate_tabs = false;
   if (params->get_info.get() && params->get_info->populate.get())
     populate_tabs = *params->get_info->populate;
 
   ExtensionWindowController* controller;
   if (!GetWindowFromWindowID(this, params->window_id, &controller))
     return false;
 
   if (populate_tabs)
-    result_.reset(controller->CreateWindowValueWithTabs());
+    SetResult(controller->CreateWindowValueWithTabs());
   else
-    result_.reset(controller->CreateWindowValue());
+    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;
 
   ExtensionWindowController* controller;
   if (!GetWindowFromWindowID(this,
                              extension_misc::kCurrentWindowId,
                              &controller)) {
     return false;
   }
   if (populate_tabs)
-    result_.reset(controller->CreateWindowValueWithTabs());
+    SetResult(controller->CreateWindowValueWithTabs());
   else
-    result_.reset(controller->CreateWindowValue());
+    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
   // ExtensionWindowList that mirrors the active behavior of BrowserList.
   Browser* browser = browser::FindAnyBrowser(
       profile(), include_incognito());
   if (!browser || !browser->window()) {
     error_ = keys::kNoLastFocusedWindowError;
     return false;
   }
   ExtensionWindowController* controller =
       browser->extension_window_controller();
   if (populate_tabs)
-    result_.reset(controller->CreateWindowValueWithTabs());
+    SetResult(controller->CreateWindowValueWithTabs());
   else
-    result_.reset(controller->CreateWindowValue());
+    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 ExtensionWindowList::WindowList& windows =
       ExtensionWindowList::GetInstance()->windows();
   for (ExtensionWindowList::WindowList::const_iterator iter =
            windows.begin();
        iter != windows.end(); ++iter) {
     if (!this->CanOperateOnWindow(*iter))
       continue;
     if (populate_tabs)
       window_list->Append((*iter)->CreateWindowValueWithTabs());
     else
       window_list->Append((*iter)->CreateWindowValue());
   }
-  result_.reset(window_list);
+  SetResult(window_list);
   return true;
 }
 
 bool CreateWindowFunction::ShouldOpenIncognitoWindow(
     const base::DictionaryValue* args,
     std::vector<GURL>* urls,
     bool* is_error) {
   *is_error = false;
   const IncognitoModePrefs::Availability incognito_availability =
       IncognitoModePrefs::GetAvailability(profile_->GetPrefs());
@@ skipping 227 matching lines @@
       // Note: Panels ignore all but the first url provided.
       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();
 
-    result_.reset(
-          panel->extension_window_controller()->CreateWindowValueWithTabs());
+    SetResult(
+        panel->extension_window_controller()->CreateWindowValueWithTabs());
     return true;
   }
 #endif
     // else fall through to create BrowserWindow
   }
 
   // Create a new BrowserWindow.
   Browser::CreateParams create_params;
   if (extension_id.empty()) {
     create_params = Browser::CreateParams(window_type, window_profile);
@@ skipping 29 matching lines @@
   if (!saw_focus_key && window_type == Browser::TYPE_PANEL)
     focused = false;
 
   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.
-    result_.reset(Value::CreateNullValue());
+    SetResult(Value::CreateNullValue());
   } else {
-    result_.reset(
+    SetResult(
         new_window->extension_window_controller()->CreateWindowValueWithTabs());
   }
 
   return true;
 }
 
 bool UpdateWindowFunction::RunImpl() {
   int window_id = extension_misc::kUnknownWindowId;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &window_id));
   DictionaryValue* update_props;
@@ skipping 117 matching lines @@
     }
   }
 
   bool draw_attention = false;
   if (update_props->HasKey(keys::kDrawAttentionKey)) {
     EXTENSION_FUNCTION_VALIDATE(update_props->GetBoolean(
         keys::kDrawAttentionKey, &draw_attention));
     controller->window()->FlashFrame(draw_attention);
   }
 
-  result_.reset(controller->CreateWindowValue());
+  SetResult(controller->CreateWindowValue());
 
   return true;
 }
 
 bool RemoveWindowFunction::RunImpl() {
   int window_id = -1;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &window_id));
 
   ExtensionWindowController* controller;
   if (!GetWindowFromWindowID(this, window_id, &controller))
@@ skipping 21 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;
   }
-  result_.reset(ExtensionTabUtil::CreateTabValue(contents->web_contents(),
-      tab_strip,
-      tab_strip->active_index()));
+  SetResult(ExtensionTabUtil::CreateTabValue(contents->web_contents(),
+                                             tab_strip,
+                                             tab_strip->active_index()));
   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;
 
-  result_.reset(ExtensionTabUtil::CreateTabList(browser));
+  SetResult(ExtensionTabUtil::CreateTabList(browser));
 
   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 94 matching lines @@
         continue;
 
       if (!MatchesQueryArg(loading, web_contents->IsLoading()))
         continue;
 
       result->Append(ExtensionTabUtil::CreateTabValue(
           web_contents, tab_strip, i));
     }
   }
 
-  result_.reset(result);
+  SetResult(result);
   return true;
 }
 
 bool CreateTabFunction::RunImpl() {
   DictionaryValue* args = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
 
   // windowId defaults to "current" window.
   int window_id = extension_misc::kCurrentWindowId;
   if (args->HasKey(keys::kWindowIdKey))
@@ skipping 110 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()) {
-    result_.reset(ExtensionTabUtil::CreateTabValue(
+    SetResult(ExtensionTabUtil::CreateTabValue(
         params.target_contents->web_contents(),
         tab_strip, new_index));
   }
 
   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;
 
-  result_.reset(ExtensionTabUtil::CreateTabValue(contents->web_contents(),
-      tab_strip,
-      tab_index));
+  SetResult(ExtensionTabUtil::CreateTabValue(contents->web_contents(),
+                                             tab_strip,
+                                             tab_index));
   return true;
 }
 
 bool GetCurrentTabFunction::RunImpl() {
   DCHECK(dispatcher());
 
   WebContents* contents = dispatcher()->delegate()->GetAssociatedWebContents();
   if (contents)
-    result_.reset(ExtensionTabUtil::CreateTabValue(contents));
+    SetResult(ExtensionTabUtil::CreateTabValue(contents));
 
   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 35 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);
-  result_.reset(
+  SetResult(
       browser->extension_window_controller()->CreateWindowValueWithTabs());
   return true;
 }
 
 UpdateTabFunction::UpdateTabFunction() : tab_contents_(NULL) {
 }
 
 bool UpdateTabFunction::RunImpl() {
   DictionaryValue* update_props = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &update_props));
@@ skipping 153 matching lines @@
     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)) {
-    result_.reset(
-        ExtensionTabUtil::CreateTabValue(tab_contents_->web_contents()));
+    SetResult(ExtensionTabUtil::CreateTabValue(tab_contents_->web_contents()));
   } else {
-    result_.reset(Value::CreateNullValue());
+    SetResult(Value::CreateNullValue());
   }
 }
 
 void UpdateTabFunction::OnExecuteCodeFinished(bool success,
                                               int32 page_id,
                                               const std::string& error) {
   if (!error.empty()) {
     CHECK(!success);
     error_ = error;
   }
@@ skipping 102 matching lines @@
     if (has_callback())
       tab_values.Append(ExtensionTabUtil::CreateTabValue(
           contents->web_contents(), source_tab_strip, new_index));
   }
 
   if (!has_callback())
     return true;
 
   // Only return the results as an array if there are multiple tabs.
   if (tab_ids.size() > 1) {
-    result_.reset(tab_values.DeepCopy());
+    SetResult(tab_values.DeepCopy());
   } else if (tab_ids.size() == 1) {
     Value* value = NULL;
     CHECK(tab_values.Get(0, &value));
-    result_.reset(value->DeepCopy());
+    SetResult(value->DeepCopy());
   }
   return true;
 }
 
 bool ReloadTabFunction::RunImpl() {
   bool bypass_cache = false;
   if (HasOptionalArgument(1)) {
       DictionaryValue* reload_props = NULL;
       EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &reload_props));
 
@@ skipping 246 matching lines @@
     return;
   }
 
   std::string base64_result;
   base::StringPiece stream_as_string(
       reinterpret_cast<const char*>(vector_as_array(&data)), data.size());
 
   base::Base64Encode(stream_as_string, &base64_result);
   base64_result.insert(0, base::StringPrintf("data:%s;base64,",
                                              mime_type.c_str()));
-  result_.reset(new StringValue(base64_result));
+  SetResult(new StringValue(base64_result));
   SendResponse(true);
 }
 
 bool DetectTabLanguageFunction::RunImpl() {
   int tab_id = 0;
   Browser* browser = NULL;
   TabContents* contents = NULL;
 
   // If |tab_id| is specified, look for it. Otherwise default to selected tab
   // in the current window.
@@ skipping 55 matching lines @@
     language = *content::Details<std::string>(details).ptr();
 
   registrar_.RemoveAll();
 
   // Call GotLanguage in all cases as we want to guarantee the callback is
   // called for every API call the extension made.
   GotLanguage(language);
 }
 
 void DetectTabLanguageFunction::GotLanguage(const std::string& language) {
-  result_.reset(Value::CreateStringValue(language.c_str()));
+  SetResult(Value::CreateStringValue(language.c_str()));
   SendResponse(true);
 
   Release();  // Balanced in Run()
 }