Added populate parameter to chrome.windows.get, chrome.windows.getCurrent,

chrome/browser/extensions/extension_tabs_module.cc

 // Copyright (c) 2011 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_tabs_module.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 120 matching lines @@
       URLFixerUpper::FixupURL(url.possibly_invalid_spec(), std::string());
   return (fixed_url.SchemeIs(chrome::kChromeUIScheme) &&
           (fixed_url.host() == chrome::kChromeUIBrowserCrashHost ||
            fixed_url.host() == chrome::kChromeUICrashHost));
 }
 
 // Reads the |value| as either a single integer value or a list of integers.
 bool ReadOneOrMoreIntegers(
     Value* value, std::vector<int>* result) {
   if (value->IsType(Value::TYPE_INTEGER)) {
-    int tab_id;
+    int tab_id = -1;
     if (!value->GetAsInteger(&tab_id))
       return false;
     result->push_back(tab_id);
     return true;
 
   } else if (value->IsType(Value::TYPE_LIST)) {
     ListValue* tabs = static_cast<ListValue*>(value);
     for (size_t i = 0; i < tabs->GetSize(); ++i) {
-      int tab_id;
+      int tab_id = -1;
       if (!tabs->GetInteger(i, &tab_id))
         return false;
       result->push_back(tab_id);
     }
     return true;
   }
   return false;
 }
 
 // A three state enum to distinguish between when a boolean query argument is
@@ skipping 18 matching lines @@
     return value ? MATCH_TRUE : MATCH_FALSE;
   }
   return NOT_SET;
 }
 
 }  // namespace
 
 // Windows ---------------------------------------------------------------------
 
 bool GetWindowFunction::RunImpl() {
-  int window_id;
+  int window_id = -1;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &window_id));
 
+  bool populate_tabs = false;
+  if (HasOptionalArgument(1)) {
+    DictionaryValue* args = NULL;
+    EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &args));
+
+    if (args->HasKey(keys::kPopulateKey)) {
+      EXTENSION_FUNCTION_VALIDATE(args->GetBoolean(keys::kPopulateKey,
+          &populate_tabs));
+    }
+  }
+
   Browser* browser = GetBrowserInProfileWithId(profile(), window_id,
                                                include_incognito(), &error_);
   if (!browser || !browser->window()) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
         keys::kWindowNotFoundError, base::IntToString(window_id));
     return false;
   }
 
-  result_.reset(ExtensionTabUtil::CreateWindowValue(browser, false));
+  result_.reset(ExtensionTabUtil::CreateWindowValue(browser, populate_tabs));
   return true;
 }
 
 bool GetCurrentWindowFunction::RunImpl() {
+  bool populate_tabs = false;
+  if (HasOptionalArgument(0)) {
+    DictionaryValue* args = NULL;
+    EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
+
+    if (args->HasKey(keys::kPopulateKey)) {
+      EXTENSION_FUNCTION_VALIDATE(args->GetBoolean(keys::kPopulateKey,
+          &populate_tabs));
+    }
+  }
+
   Browser* browser = GetCurrentBrowser();
   if (!browser || !browser->window()) {
     error_ = keys::kNoCurrentWindowError;
     return false;
   }
-  result_.reset(ExtensionTabUtil::CreateWindowValue(browser, false));
+  result_.reset(ExtensionTabUtil::CreateWindowValue(browser, populate_tabs));
   return true;
 }
 
 bool GetLastFocusedWindowFunction::RunImpl() {
+  bool populate_tabs = false;
+  if (HasOptionalArgument(0)) {
+    DictionaryValue* args = NULL;
+    EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
+
+    if (args->HasKey(keys::kPopulateKey)) {
+      EXTENSION_FUNCTION_VALIDATE(args->GetBoolean(keys::kPopulateKey,
+          &populate_tabs));
+    }
+  }
+
   Browser* browser = BrowserList::FindAnyBrowser(
       profile(), include_incognito());
   if (!browser || !browser->window()) {
     error_ = keys::kNoLastFocusedWindowError;
     return false;
   }
-  result_.reset(ExtensionTabUtil::CreateWindowValue(browser, false));
+  result_.reset(ExtensionTabUtil::CreateWindowValue(browser, populate_tabs));
   return true;
 }
 
 bool GetAllWindowsFunction::RunImpl() {
   bool populate_tabs = false;
   if (HasOptionalArgument(0)) {
-    DictionaryValue* args;
+    DictionaryValue* args = NULL;
     EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
 
     if (args->HasKey(keys::kPopulateKey)) {
       EXTENSION_FUNCTION_VALIDATE(args->GetBoolean(keys::kPopulateKey,
           &populate_tabs));
     }
   }
 
   result_.reset(new ListValue());
   Profile* incognito_profile =
@@ skipping 106 matching lines @@
           error_ = keys::kNoCrashBrowserError;
           return false;
         }
         urls.push_back(url);
       }
     }
   }
 
   // Look for optional tab id.
   if (args) {
-    int tab_id;
+    int tab_id = -1;
     if (args->HasKey(keys::kTabIdKey)) {
       EXTENSION_FUNCTION_VALIDATE(args->GetInteger(keys::kTabIdKey, &tab_id));
 
       // Find the tab and detach it from the original window.
       Browser* source_browser = NULL;
       TabStripModel* source_tab_strip = NULL;
       int tab_index = -1;
       if (!GetTabById(tab_id, profile(), include_incognito(),
                       &source_browser, &source_tab_strip, &contents,
                       &tab_index, &error_))
@@ skipping 30 matching lines @@
   popup_bounds = window_bounds;  // Use window size as default for popups
 #endif
 
   Profile* window_profile = profile();
   Browser::Type window_type = Browser::TYPE_TABBED;
   bool focused = true;
   bool saw_focus_key = false;
   std::string extension_id;
 
   // Decide whether we are opening a normal window or an incognito window.
-  bool is_error;
+  bool is_error = true;
   bool open_incognito_window = ShouldOpenIncognitoWindow(args, &urls,
                                                          &is_error);
   if (is_error) {
     // error_ member variable is set inside of ShouldOpenIncognitoWindow.
     return false;
   }
   if (open_incognito_window) {
     window_profile = window_profile->GetOffTheRecordProfile();
   }
 
   if (args) {
     // Any part of the bounds can optionally be set by the caller.
-    int bounds_val;
+    int bounds_val = -1;
     if (args->HasKey(keys::kLeftKey)) {
       EXTENSION_FUNCTION_VALIDATE(args->GetInteger(keys::kLeftKey,
                                                    &bounds_val));
       window_bounds.set_x(bounds_val);
       popup_bounds.set_x(bounds_val);
       panel_bounds.set_x(bounds_val);
     }
 
     if (args->HasKey(keys::kTopKey)) {
       EXTENSION_FUNCTION_VALIDATE(args->GetInteger(keys::kTopKey,
@@ skipping 80 matching lines @@
     // Don't expose incognito windows if the extension isn't allowed.
     result_.reset(Value::CreateNullValue());
   } else {
     result_.reset(ExtensionTabUtil::CreateWindowValue(new_window, true));
   }
 
   return true;
 }
 
 bool UpdateWindowFunction::RunImpl() {
-  int window_id;
+  int window_id = -1;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &window_id));
   DictionaryValue* update_props;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &update_props));
 
   Browser* browser = GetBrowserInProfileWithId(profile(), window_id,
                                                include_incognito(), &error_);
   if (!browser || !browser->window()) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
         keys::kWindowNotFoundError, base::IntToString(window_id));
     return false;
@@ skipping 102 matching lines @@
     if (draw_attention)
         browser->window()->FlashFrame();
   }
 
   result_.reset(ExtensionTabUtil::CreateWindowValue(browser, false));
 
   return true;
 }
 
 bool RemoveWindowFunction::RunImpl() {
-  int window_id;
+  int window_id = -1;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &window_id));
 
   Browser* browser = GetBrowserInProfileWithId(profile(), window_id,
                                                include_incognito(), &error_);
   if (!browser)
     return false;
 
   // Don't let the extension remove the window if the user is dragging tabs
   // in that window.
   if (!browser->IsTabStripEditable()) {
@@ skipping 141 matching lines @@
       result->Append(ExtensionTabUtil::CreateTabValue(
           tab_contents, tab_strip, i));
     }
   }
 
   result_.reset(result);
   return true;
 }
 
 bool CreateTabFunction::RunImpl() {
-  DictionaryValue* args;
+  DictionaryValue* args = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
 
   Browser *browser;
   // windowId defaults to "current" window.
   int window_id = -1;
   if (args->HasKey(keys::kWindowIdKey)) {
     EXTENSION_FUNCTION_VALIDATE(args->GetInteger(
         keys::kWindowIdKey, &window_id));
     browser = GetBrowserInProfileWithId(profile(), window_id,
                                         include_incognito(), &error_);
@@ skipping 90 matching lines @@
         params.target_contents->tab_contents(),
         params.browser->tabstrip_model(),
         params.browser->tabstrip_model()->GetIndexOfTabContents(
             params.target_contents)));
   }
 
   return true;
 }
 
 bool GetTabFunction::RunImpl() {
-  int tab_id;
+  int tab_id = -1;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id));
 
   TabStripModel* tab_strip = NULL;
   TabContentsWrapper* 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->tab_contents(),
@@ skipping 67 matching lines @@
   selection.set_active(active_index);
   browser->tabstrip_model()->SetSelectionFromModel(selection);
   result_.reset(ExtensionTabUtil::CreateWindowValue(browser, true));
   return true;
 }
 
 UpdateTabFunction::UpdateTabFunction() {
 }
 
 bool UpdateTabFunction::RunImpl() {
-  DictionaryValue* update_props;
+  DictionaryValue* update_props = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &update_props));
 
   Value* tab_value = NULL;
   if (HasOptionalArgument(0)) {
     EXTENSION_FUNCTION_VALIDATE(args_->Get(0, &tab_value));
   }
 
   int tab_id = -1;
   TabContentsWrapper* contents = NULL;
   if (tab_value == NULL || tab_value->IsType(Value::TYPE_NULL)) {
@@ skipping 129 matching lines @@
   }
 
   SendResponse(true);
   return true;
 }
 
 bool UpdateTabFunction::OnMessageReceived(const IPC::Message& message) {
   if (message.type() != ExtensionHostMsg_ExecuteCodeFinished::ID)
     return false;
 
-  int message_request_id;
+  int message_request_id = -1;
   void* iter = NULL;
   if (!message.ReadInt(&iter, &message_request_id)) {
     NOTREACHED() << "malformed extension message";
     return true;
   }
 
   if (message_request_id != request_id())
     return false;
 
   IPC_BEGIN_MESSAGE_MAP(UpdateTabFunction, message)
@@ skipping 17 matching lines @@
   Release();  // balanced in Execute()
 }
 
 bool MoveTabsFunction::RunImpl() {
   Value* tab_value = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->Get(0, &tab_value));
 
   std::vector<int> tab_ids;
   EXTENSION_FUNCTION_VALIDATE(ReadOneOrMoreIntegers(tab_value, &tab_ids));
 
-  DictionaryValue* update_props;
+  DictionaryValue* update_props = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &update_props));
 
-  int new_index;
+  int new_index = -1;
   EXTENSION_FUNCTION_VALIDATE(update_props->GetInteger(
       keys::kIndexKey, &new_index));
   EXTENSION_FUNCTION_VALIDATE(new_index >= 0);
 
   ListValue tab_values;
   for (size_t i = 0; i < tab_ids.size(); ++i) {
     Browser* source_browser = NULL;
     TabStripModel* source_tab_strip = NULL;
     TabContentsWrapper* contents = NULL;
     int tab_index = -1;
     if (!GetTabById(tab_ids[i], profile(), include_incognito(),
                     &source_browser, &source_tab_strip, &contents,
                     &tab_index, &error_))
       return false;
 
     // Don't let the extension move the tab if the user is dragging tabs.
     if (!source_browser->IsTabStripEditable()) {
       error_ = keys::kTabStripNotEditableError;
       return false;
     }
 
     // Insert the tabs one after another.
     new_index += i;
 
     if (update_props->HasKey(keys::kWindowIdKey)) {
-      Browser* target_browser;
-      int window_id;
+      Browser* target_browser = NULL;
+      int window_id = -1;
       EXTENSION_FUNCTION_VALIDATE(update_props->GetInteger(
           keys::kWindowIdKey, &window_id));
       target_browser = GetBrowserInProfileWithId(profile(), window_id,
                                                  include_incognito(), &error_);
       if (!target_browser)
         return false;
 
       if (!target_browser->IsTabStripEditable()) {
         error_ = keys::kTabStripNotEditableError;
         return false;
@@ skipping 88 matching lines @@
   if (tab_value == NULL || tab_value->IsType(Value::TYPE_NULL)) {
     Browser* browser = GetCurrentBrowser();
     if (!browser) {
       error_ = keys::kNoCurrentWindowError;
       return false;
     }
 
     if (!ExtensionTabUtil::GetDefaultTab(browser, &contents, NULL))
       return false;
   } else {
-    int tab_id;
+    int tab_id = -1;
     EXTENSION_FUNCTION_VALIDATE(tab_value->GetAsInteger(&tab_id));
 
     Browser* browser = NULL;
     if (!GetTabById(tab_id, profile(), include_incognito(),
                     &browser, NULL, &contents, NULL, &error_))
     return false;
   }
 
   TabContents* tab_contents = contents->tab_contents();
   if (tab_contents->showing_interstitial_page()) {
@@ skipping 35 matching lines @@
     // path should ensure that the tab is safely closed under such
     // circumstances, whereas |Browser::CloseTabContents()| does not.
     RenderViewHost* render_view_host =
         contents->tab_contents()->render_view_host();
     render_view_host->delegate()->Close(render_view_host);
   }
   return true;
 }
 
 bool CaptureVisibleTabFunction::RunImpl() {
-  Browser* browser;
+  Browser* browser = NULL;
   // windowId defaults to "current" window.
   int window_id = -1;
 
   if (HasOptionalArgument(0)) {
     EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &window_id));
     browser = GetBrowserInProfileWithId(profile(), window_id,
                                         include_incognito(), &error_);
   } else {
     browser = GetCurrentBrowser();
   }
 
   if (!browser) {
     error_ = keys::kNoCurrentWindowError;
     return false;
   }
 
   image_format_ = FORMAT_JPEG;  // Default format is JPEG.
   image_quality_ = kDefaultQuality;  // Default quality setting.
 
   if (HasOptionalArgument(1)) {
-    DictionaryValue* options;
+    DictionaryValue* options = NULL;
     EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &options));
 
     if (options->HasKey(keys::kFormatKey)) {
       std::string format;
       EXTENSION_FUNCTION_VALIDATE(
           options->GetString(keys::kFormatKey, &format));
 
       if (format == keys::kFormatValueJpeg) {
         image_format_ = FORMAT_JPEG;
       } else if (format == keys::kFormatValuePng) {
@@ skipping 202 matching lines @@
   // called for every API call the extension made.
   GotLanguage(language);
 }
 
 void DetectTabLanguageFunction::GotLanguage(const std::string& language) {
   result_.reset(Value::CreateStringValue(language.c_str()));
   SendResponse(true);
 
   Release();  // Balanced in Run()
 }