Extension API Renaming/Consistency changes

chrome/browser/extensions/extension_tabs_module.cc

 // Copyright (c) 2009 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 "base/gfx/jpeg_codec.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
@@ skipping 12 matching lines @@
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "net/base/base64.h"
 #include "skia/ext/image_operations.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 
 namespace keys = extension_tabs_module_constants;
 
 // Forward declare static helper functions defined below.
-static DictionaryValue* CreateWindowValue(Browser* browser, bool populate_tabs);
-static ListValue* CreateTabList(Browser* browser);
 
 // |error_message| can optionally be passed in a will be set with an appropriate
 // message if the window cannot be found by id.
 static Browser* GetBrowserInProfileWithId(Profile* profile,
                                           const int window_id,
                                           std::string* error_message);
 
 // |error_message| can optionally be passed in a will be set with an appropriate
 // message if the tab cannot be found by id.
 static bool GetTabById(int tab_id, Profile* profile, Browser** browser,
@@ skipping 45 matching lines @@
     int tab_index = tab_strip->GetIndexOfTabContents(contents);
     if (tab_index != -1) {
       return ExtensionTabUtil::CreateTabValue(contents, tab_strip, tab_index);
     }
   }
 
   // Couldn't find it.  This can happen if the tab is being dragged.
   return ExtensionTabUtil::CreateTabValue(contents, NULL, -1);
 }
 
+ListValue* ExtensionTabUtil::CreateTabList(const Browser* browser) {
+  ListValue* tab_list = new ListValue();
+  TabStripModel* tab_strip = browser->tabstrip_model();
+  for (int i = 0; i < tab_strip->count(); ++i) {
+    tab_list->Append(ExtensionTabUtil::CreateTabValue(
+        tab_strip->GetTabContentsAt(i), tab_strip, i));
+  }
+
+  return tab_list;
+}
+
 DictionaryValue* ExtensionTabUtil::CreateTabValue(
     const TabContents* contents, TabStripModel* tab_strip, int tab_index) {
   TabStatus status = GetTabStatus(contents);
 
   DictionaryValue* result = new DictionaryValue();
   result->SetInteger(keys::kIdKey, ExtensionTabUtil::GetTabId(contents));
   result->SetInteger(keys::kIndexKey, tab_index);
   result->SetInteger(keys::kWindowIdKey,
                      ExtensionTabUtil::GetWindowIdOfTab(contents));
   result->SetString(keys::kUrlKey, contents->GetURL().spec());
   result->SetString(keys::kStatusKey, GetTabStatusText(status));
   result->SetBoolean(keys::kSelectedKey,
                      tab_strip && tab_index == tab_strip->selected_index());
 
   if (status != TAB_LOADING) {
     result->SetString(keys::kTitleKey, UTF16ToWide(contents->GetTitle()));
 
     NavigationEntry* entry = contents->controller().GetActiveEntry();
     if (entry) {
       if (entry->favicon().is_valid())
         result->SetString(keys::kFavIconUrlKey, entry->favicon().url().spec());
     }
   }
 
   return result;
 }
 
+// if |populate| is true, each window gets a list property |tabs| which contains
+// fully populated tab objects.
+DictionaryValue* ExtensionTabUtil::CreateWindowValue(const Browser* browser,
+                                                     bool populate_tabs) {
+  DictionaryValue* result = new DictionaryValue();
+  result->SetInteger(keys::kIdKey, ExtensionTabUtil::GetWindowId(
+      browser));
+  bool focused = false;
+  if (browser->window())
+    focused = browser->window()->IsActive();
+
+  result->SetBoolean(keys::kFocusedKey, focused);
+  gfx::Rect bounds = browser->window()->GetRestoredBounds();
+
+  // TODO(rafaelw): zIndex ?
+  result->SetInteger(keys::kLeftKey, bounds.x());
+  result->SetInteger(keys::kTopKey, bounds.y());
+  result->SetInteger(keys::kWidthKey, bounds.width());
+  result->SetInteger(keys::kHeightKey, bounds.height());
+
+  if (populate_tabs) {
+    result->Set(keys::kTabsKey, ExtensionTabUtil::CreateTabList(browser));
+  }
+
+  return result;
+}
+
 bool ExtensionTabUtil::GetTabById(int tab_id, Profile* profile,
                                   Browser** browser,
                                   TabStripModel** tab_strip,
                                   TabContents** contents,
                                   int* tab_index) {
   Browser* target_browser;
   TabStripModel* target_tab_strip;
   TabContents* target_contents;
   for (BrowserList::const_iterator iter = BrowserList::begin();
        iter != BrowserList::end(); ++iter) {
@@ skipping 22 matching lines @@
 // Windows ---------------------------------------------------------------------
 
 bool GetWindowFunction::RunImpl() {
   int window_id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetAsInteger(&window_id));
 
   Browser* browser = GetBrowserInProfileWithId(profile(), window_id, &error_);
   if (!browser)
     return false;
 
-  result_.reset(CreateWindowValue(browser, false));
+  result_.reset(ExtensionTabUtil::CreateWindowValue(browser, false));
   return true;
 }
 
 bool GetCurrentWindowFunction::RunImpl() {
   Browser* browser = dispatcher()->GetBrowser();
   if (!browser) {
     error_ = keys::kNoCurrentWindowError;
     return false;
   }
-  result_.reset(CreateWindowValue(browser, false));
+  result_.reset(ExtensionTabUtil::CreateWindowValue(browser, false));
   return true;
 }
 
 bool GetLastFocusedWindowFunction::RunImpl() {
   Browser* browser = BrowserList::GetLastActiveWithProfile(profile());
   if (!browser) {
     error_ = keys::kNoLastFocusedWindowError;
     return false;
   }
-  result_.reset(CreateWindowValue(browser, false));
+  result_.reset(ExtensionTabUtil::CreateWindowValue(browser, false));
   return true;
 }
 
 bool GetAllWindowsFunction::RunImpl() {
   bool populate_tabs = false;
   if (!args_->IsType(Value::TYPE_NULL)) {
-    EXTENSION_FUNCTION_VALIDATE(args_->GetAsBoolean(&populate_tabs));
+    EXTENSION_FUNCTION_VALIDATE(args_->IsType(Value::TYPE_DICTIONARY));
+    const DictionaryValue* args = static_cast<const DictionaryValue*>(args_);
+    if (args->HasKey(keys::kPopulateKey)) {
+      EXTENSION_FUNCTION_VALIDATE(args->GetBoolean(keys::kPopulateKey,
+          &populate_tabs));
+    }
   }
 
   result_.reset(new ListValue());
   for (BrowserList::const_iterator browser = BrowserList::begin();
     browser != BrowserList::end(); ++browser) {
       // Only examine browsers in the current profile.
       if ((*browser)->profile() == profile()) {
         static_cast<ListValue*>(result_.get())->
-          Append(CreateWindowValue(*browser, populate_tabs));
+          Append(ExtensionTabUtil::CreateWindowValue(*browser, populate_tabs));
       }
   }
 
   return true;
 }
 
 bool CreateWindowFunction::RunImpl() {
   scoped_ptr<GURL> url(new GURL());
 
   // Look for optional url.
@@ skipping 57 matching lines @@
 
   Browser* new_window = Browser::Create(dispatcher()->profile());
   new_window->AddTabWithURL(*(url.get()), GURL(), PageTransition::LINK, true,
                             -1, false, NULL);
 
   new_window->window()->SetBounds(bounds);
   new_window->window()->Show();
 
   // TODO(rafaelw): support |focused|, |zIndex|
 
-  result_.reset(CreateWindowValue(new_window, false));
+  result_.reset(ExtensionTabUtil::CreateWindowValue(new_window, false));
 
   return true;
 }
 
 bool UpdateWindowFunction::RunImpl() {
   EXTENSION_FUNCTION_VALIDATE(args_->IsType(Value::TYPE_LIST));
   const ListValue* args = static_cast<const ListValue*>(args_);
   int window_id;
   EXTENSION_FUNCTION_VALIDATE(args->GetInteger(0, &window_id));
   DictionaryValue* update_props;
@@ skipping 29 matching lines @@
 
   if (update_props->HasKey(keys::kHeightKey)) {
     EXTENSION_FUNCTION_VALIDATE(update_props->GetInteger(
         keys::kHeightKey,
         &bounds_val));
     bounds.set_height(bounds_val);
   }
 
   browser->window()->SetBounds(bounds);
   // TODO(rafaelw): Support |focused|.
-  result_.reset(CreateWindowValue(browser, false));
+  result_.reset(ExtensionTabUtil::CreateWindowValue(browser, false));
 
   return true;
 }
 
 bool RemoveWindowFunction::RunImpl() {
   int window_id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetAsInteger(&window_id));
 
   Browser* browser = GetBrowserInProfileWithId(profile(), window_id, &error_);
   if (!browser)
@@ skipping 41 matching lines @@
     EXTENSION_FUNCTION_VALIDATE(args_->GetAsInteger(&window_id));
     browser = GetBrowserInProfileWithId(profile(), window_id, &error_);
   } else {
     browser = dispatcher()->GetBrowser();
     if (!browser)
       error_ = keys::kNoCurrentWindowError;
   }
   if (!browser)
     return false;
 
-  result_.reset(CreateTabList(browser));
+  result_.reset(ExtensionTabUtil::CreateTabList(browser));
 
   return true;
 }
 
 bool CreateTabFunction::RunImpl() {
   EXTENSION_FUNCTION_VALIDATE(args_->IsType(Value::TYPE_DICTIONARY));
   const DictionaryValue* args = static_cast<const DictionaryValue*>(args_);
 
   Browser *browser;
   // windowId defaults to "current" window.
@@ skipping 355 matching lines @@
                                         const NotificationDetails& details) {
   DCHECK(type == NotificationType::TAB_LANGUAGE_DETERMINED);
   std::string language(*Details<std::string>(details).ptr());
   result_.reset(Value::CreateStringValue(language.c_str()));
   SendResponse(true);
   Release();  // balanced in Run()
 }
 
 // static helpers
 
-// if |populate| is true, each window gets a list property |tabs| which contains
-// fully populated tab objects.
-static DictionaryValue* CreateWindowValue(Browser* browser,
-                                          bool populate_tabs) {
-  DictionaryValue* result = new DictionaryValue();
-  result->SetInteger(keys::kIdKey, ExtensionTabUtil::GetWindowId(
-      browser));
-  result->SetBoolean(keys::kFocusedKey,
-      browser->window()->IsActive());
-  gfx::Rect bounds = browser->window()->GetRestoredBounds();
-
-  // TODO(rafaelw): zIndex ?
-  result->SetInteger(keys::kLeftKey, bounds.x());
-  result->SetInteger(keys::kTopKey, bounds.y());
-  result->SetInteger(keys::kWidthKey, bounds.width());
-  result->SetInteger(keys::kHeightKey, bounds.height());
-
-  if (populate_tabs) {
-    result->Set(keys::kTabsKey, CreateTabList(browser));
-  }
-
-  return result;
-}
-
-static ListValue* CreateTabList(Browser* browser) {
-  ListValue* tab_list = new ListValue();
-  TabStripModel* tab_strip = browser->tabstrip_model();
-  for (int i = 0; i < tab_strip->count(); ++i) {
-    tab_list->Append(ExtensionTabUtil::CreateTabValue(
-        tab_strip->GetTabContentsAt(i), tab_strip, i));
-  }
-
-  return tab_list;
-}
-
 static Browser* GetBrowserInProfileWithId(Profile* profile,
                                           const int window_id,
                                           std::string* error_message) {
   for (BrowserList::const_iterator browser = BrowserList::begin();
       browser != BrowserList::end(); ++browser) {
     if ((*browser)->profile() == profile &&
         ExtensionTabUtil::GetWindowId(*browser) == window_id)
       return *browser;
   }
 
@@ skipping 19 matching lines @@
   if (ExtensionTabUtil::GetTabById(tab_id, profile, browser, tab_strip,
                                    contents, tab_index))
     return true;
 
   if (error_message)
     *error_message = ExtensionErrorUtils::FormatErrorMessage(
         keys::kTabNotFoundError, IntToString(tab_id));
 
   return false;
 }