src/chrome/browser/extensions/api/tabs/tabs_api.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/extensions/api/tabs/tabs_api.h"
   6
   7 #include <algorithm>
   8 #include <limits>
   9 #include <vector>
  10
  11 #include "base/bind.h"
  12 #include "base/command_line.h"
  13 #include "base/logging.h"
  14 #include "base/memory/ref_counted_memory.h"
  15 #include "base/message_loop/message_loop.h"
  16 #include "base/prefs/pref_service.h"
  17 #include "base/stl_util.h"
  18 #include "base/strings/string16.h"
  19 #include "base/strings/string_number_conversions.h"
  20 #include "base/strings/string_util.h"
  21 #include "base/strings/utf_string_conversions.h"
  22 #include "chrome/browser/apps/scoped_keep_alive.h"
  23 #include "chrome/browser/chrome_notification_types.h"
  24 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
  25 #include "chrome/browser/extensions/api/tabs/windows_util.h"
  26 #include "chrome/browser/extensions/extension_service.h"
  27 #include "chrome/browser/extensions/extension_tab_util.h"
  28 #include "chrome/browser/extensions/tab_helper.h"
  29 #include "chrome/browser/extensions/window_controller.h"
  30 #include "chrome/browser/extensions/window_controller_list.h"
  31 #include "chrome/browser/prefs/incognito_mode_prefs.h"
  32 #include "chrome/browser/profiles/profile.h"
  33 #include "chrome/browser/sessions/session_tab_helper.h"
  34 #include "chrome/browser/translate/chrome_translate_client.h"
  35 #include "chrome/browser/ui/apps/chrome_app_delegate.h"
  36 #include "chrome/browser/ui/browser.h"
  37 #include "chrome/browser/ui/browser_commands.h"
  38 #include "chrome/browser/ui/browser_finder.h"
  39 #include "chrome/browser/ui/browser_iterator.h"
  40 #include "chrome/browser/ui/browser_navigator.h"
  41 #include "chrome/browser/ui/browser_tabstrip.h"
  42 #include "chrome/browser/ui/browser_window.h"
  43 #include "chrome/browser/ui/host_desktop.h"
  44 #include "chrome/browser/ui/panels/panel_manager.h"
  45 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  46 #include "chrome/browser/ui/window_sizer/window_sizer.h"
  47 #include "chrome/browser/ui/zoom/zoom_controller.h"
  48 #include "chrome/browser/web_applications/web_app.h"
  49 #include "chrome/common/chrome_switches.h"
  50 #include "chrome/common/extensions/api/i18n/default_locale_handler.h"
  51 #include "chrome/common/extensions/api/tabs.h"
  52 #include "chrome/common/extensions/api/windows.h"
  53 #include "chrome/common/extensions/extension_constants.h"
  54 #include "chrome/common/pref_names.h"
  55 #include "chrome/common/url_constants.h"
  56 #include "components/pref_registry/pref_registry_syncable.h"
  57 #include "components/translate/core/browser/language_state.h"
  58 #include "components/translate/core/common/language_detection_details.h"
  59 #include "content/public/browser/navigation_controller.h"
  60 #include "content/public/browser/navigation_entry.h"
  61 #include "content/public/browser/notification_details.h"
  62 #include "content/public/browser/notification_source.h"
  63 #include "content/public/browser/render_process_host.h"
  64 #include "content/public/browser/render_view_host.h"
  65 #include "content/public/browser/render_widget_host_view.h"
  66 #include "content/public/browser/web_contents.h"
  67 #include "content/public/common/url_constants.h"
  68 #include "extensions/browser/app_window/app_window.h"
  69 #include "extensions/browser/extension_function_dispatcher.h"
  70 #include "extensions/browser/extension_function_util.h"
  71 #include "extensions/browser/extension_host.h"
  72 #include "extensions/browser/file_reader.h"
  73 #include "extensions/browser/script_executor.h"
  74 #include "extensions/common/api/extension_types.h"
  75 #include "extensions/common/constants.h"
  76 #include "extensions/common/error_utils.h"
  77 #include "extensions/common/extension.h"
  78 #include "extensions/common/manifest_constants.h"
  79 #include "extensions/common/message_bundle.h"
  80 #include "extensions/common/permissions/permissions_data.h"
  81 #include "extensions/common/user_script.h"
  82 #include "skia/ext/image_operations.h"
  83 #include "skia/ext/platform_canvas.h"
  84 #include "third_party/skia/include/core/SkBitmap.h"
  85 #include "ui/base/models/list_selection_model.h"
  86 #include "ui/base/ui_base_types.h"
  87
  88 #if defined(USE_ASH)
  89 #include "ash/ash_switches.h"
  90 #include "chrome/browser/extensions/api/tabs/ash_panel_contents.h"
  91 #include "extensions/browser/app_window/app_window_registry.h"
  92 #endif
  93
  94 using content::BrowserThread;
  95 using content::NavigationController;
  96 using content::NavigationEntry;
  97 using content::OpenURLParams;
  98 using content::Referrer;
  99 using content::WebContents;
 100
 101 namespace extensions {
 102
 103 namespace windows = api::windows;
 104 namespace keys = tabs_constants;
 105 namespace tabs = api::tabs;
 106
 107 using core_api::extension_types::InjectDetails;
 108
 109 namespace {
 110
 111 bool GetBrowserFromWindowID(ChromeUIThreadExtensionFunction* function,
 112                             int window_id,
 113                             Browser** browser) {
 114   std::string error;
 115   Browser* result;
 116   result =
 117       ExtensionTabUtil::GetBrowserFromWindowID(function, window_id, &error);
 118   if (!result) {
 119     function->SetError(error);
 120     return false;
 121   }
 122
 123   *browser = result;
 124   return true;
 125 }
 126
 127 bool GetBrowserFromWindowID(ChromeExtensionFunctionDetails* details,
 128                             int window_id,
 129                             Browser** browser) {
 130   std::string error;
 131   Browser* result;
 132   result =
 133       ExtensionTabUtil::GetBrowserFromWindowID(*details, window_id, &error);
 134   if (!result) {
 135     details->function()->SetError(error);
 136     return false;
 137   }
 138
 139   *browser = result;
 140   return true;
 141 }
 142
 143 // |error_message| can optionally be passed in and will be set with an
 144 // appropriate message if the tab cannot be found by id.
 145 bool GetTabById(int tab_id,
 146                 Profile* profile,
 147                 bool include_incognito,
 148                 Browser** browser,
 149                 TabStripModel** tab_strip,
 150                 content::WebContents** contents,
 151                 int* tab_index,
 152                 std::string* error_message) {
 153   if (ExtensionTabUtil::GetTabById(tab_id, profile, include_incognito,
 154                                    browser, tab_strip, contents, tab_index)) {
 155     return true;
 156   }
 157
 158   if (error_message) {
 159     *error_message = ErrorUtils::FormatErrorMessage(
 160         keys::kTabNotFoundError, base::IntToString(tab_id));
 161   }
 162
 163   return false;
 164 }
 165
 166 // Returns true if either |boolean| is a null pointer, or if |*boolean| and
 167 // |value| are equal. This function is used to check if a tab's parameters match
 168 // those of the browser.
 169 bool MatchesBool(bool* boolean, bool value) {
 170   return !boolean || *boolean == value;
 171 }
 172
 173 template <typename T>
 174 void AssignOptionalValue(const scoped_ptr<T>& source,
 175                          scoped_ptr<T>& destination) {
 176   if (source.get()) {
 177     destination.reset(new T(*source.get()));
 178   }
 179 }
 180
 181 }  // namespace
 182
 183 void ZoomModeToZoomSettings(ZoomController::ZoomMode zoom_mode,
 184                             api::tabs::ZoomSettings* zoom_settings) {
 185   DCHECK(zoom_settings);
 186   switch (zoom_mode) {
 187     case ZoomController::ZOOM_MODE_DEFAULT:
 188       zoom_settings->mode = api::tabs::ZoomSettings::MODE_AUTOMATIC;
 189       zoom_settings->scope = api::tabs::ZoomSettings::SCOPE_PER_ORIGIN;
 190       break;
 191     case ZoomController::ZOOM_MODE_ISOLATED:
 192       zoom_settings->mode = api::tabs::ZoomSettings::MODE_AUTOMATIC;
 193       zoom_settings->scope = api::tabs::ZoomSettings::SCOPE_PER_TAB;
 194       break;
 195     case ZoomController::ZOOM_MODE_MANUAL:
 196       zoom_settings->mode = api::tabs::ZoomSettings::MODE_MANUAL;
 197       zoom_settings->scope = api::tabs::ZoomSettings::SCOPE_PER_TAB;
 198       break;
 199     case ZoomController::ZOOM_MODE_DISABLED:
 200       zoom_settings->mode = api::tabs::ZoomSettings::MODE_DISABLED;
 201       zoom_settings->scope = api::tabs::ZoomSettings::SCOPE_PER_TAB;
 202       break;
 203   }
 204 }
 205
 206 // Windows ---------------------------------------------------------------------
 207
 208 bool WindowsGetFunction::RunSync() {
 209   scoped_ptr<windows::Get::Params> params(windows::Get::Params::Create(*args_));
 210   EXTENSION_FUNCTION_VALIDATE(params.get());
 211
 212   bool populate_tabs = false;
 213   if (params->get_info.get() && params->get_info->populate.get())
 214     populate_tabs = *params->get_info->populate;
 215
 216   WindowController* controller;
 217   if (!windows_util::GetWindowFromWindowID(this,
 218                                            params->window_id,
 219                                            &controller)) {
 220     return false;
 221   }
 222
 223   if (populate_tabs)
 224     SetResult(controller->CreateWindowValueWithTabs(extension()));
 225   else
 226     SetResult(controller->CreateWindowValue());
 227   return true;
 228 }
 229
 230 bool WindowsGetCurrentFunction::RunSync() {
 231   scoped_ptr<windows::GetCurrent::Params> params(
 232       windows::GetCurrent::Params::Create(*args_));
 233   EXTENSION_FUNCTION_VALIDATE(params.get());
 234
 235   bool populate_tabs = false;
 236   if (params->get_info.get() && params->get_info->populate.get())
 237     populate_tabs = *params->get_info->populate;
 238
 239   WindowController* controller;
 240   if (!windows_util::GetWindowFromWindowID(this,
 241                                            extension_misc::kCurrentWindowId,
 242                                            &controller)) {
 243     return false;
 244   }
 245   if (populate_tabs)
 246     SetResult(controller->CreateWindowValueWithTabs(extension()));
 247   else
 248     SetResult(controller->CreateWindowValue());
 249   return true;
 250 }
 251
 252 bool WindowsGetLastFocusedFunction::RunSync() {
 253   scoped_ptr<windows::GetLastFocused::Params> params(
 254       windows::GetLastFocused::Params::Create(*args_));
 255   EXTENSION_FUNCTION_VALIDATE(params.get());
 256
 257   bool populate_tabs = false;
 258   if (params->get_info.get() && params->get_info->populate.get())
 259     populate_tabs = *params->get_info->populate;
 260
 261   // Note: currently this returns the last active browser. If we decide to
 262   // include other window types (e.g. panels), we will need to add logic to
 263   // WindowControllerList that mirrors the active behavior of BrowserList.
 264   Browser* browser = chrome::FindAnyBrowser(
 265       GetProfile(), include_incognito(), chrome::GetActiveDesktop());
 266   if (!browser || !browser->window()) {
 267     error_ = keys::kNoLastFocusedWindowError;
 268     return false;
 269   }
 270   WindowController* controller =
 271       browser->extension_window_controller();
 272   if (populate_tabs)
 273     SetResult(controller->CreateWindowValueWithTabs(extension()));
 274   else
 275     SetResult(controller->CreateWindowValue());
 276   return true;
 277 }
 278
 279 bool WindowsGetAllFunction::RunSync() {
 280   scoped_ptr<windows::GetAll::Params> params(
 281       windows::GetAll::Params::Create(*args_));
 282   EXTENSION_FUNCTION_VALIDATE(params.get());
 283
 284   bool populate_tabs = false;
 285   if (params->get_info.get() && params->get_info->populate.get())
 286     populate_tabs = *params->get_info->populate;
 287
 288   base::ListValue* window_list = new base::ListValue();
 289   const WindowControllerList::ControllerList& windows =
 290       WindowControllerList::GetInstance()->windows();
 291   for (WindowControllerList::ControllerList::const_iterator iter =
 292            windows.begin();
 293        iter != windows.end(); ++iter) {
 294     if (!this->CanOperateOnWindow(*iter))
 295       continue;
 296     if (populate_tabs)
 297       window_list->Append((*iter)->CreateWindowValueWithTabs(extension()));
 298     else
 299       window_list->Append((*iter)->CreateWindowValue());
 300   }
 301   SetResult(window_list);
 302   return true;
 303 }
 304
 305 bool WindowsCreateFunction::ShouldOpenIncognitoWindow(
 306     const windows::Create::Params::CreateData* create_data,
 307     std::vector<GURL>* urls, bool* is_error) {
 308   *is_error = false;
 309   const IncognitoModePrefs::Availability incognito_availability =
 310       IncognitoModePrefs::GetAvailability(GetProfile()->GetPrefs());
 311   bool incognito = false;
 312   if (create_data && create_data->incognito) {
 313     incognito = *create_data->incognito;
 314     if (incognito && incognito_availability == IncognitoModePrefs::DISABLED) {
 315       error_ = keys::kIncognitoModeIsDisabled;
 316       *is_error = true;
 317       return false;
 318     }
 319     if (!incognito && incognito_availability == IncognitoModePrefs::FORCED) {
 320       error_ = keys::kIncognitoModeIsForced;
 321       *is_error = true;
 322       return false;
 323     }
 324   } else if (incognito_availability == IncognitoModePrefs::FORCED) {
 325     // If incognito argument is not specified explicitly, we default to
 326     // incognito when forced so by policy.
 327     incognito = true;
 328   }
 329
 330   // Remove all URLs that are not allowed in an incognito session. Note that a
 331   // ChromeOS guest session is not considered incognito in this case.
 332   if (incognito && !GetProfile()->IsGuestSession()) {
 333     std::string first_url_erased;
 334     for (size_t i = 0; i < urls->size();) {
 335       if (chrome::IsURLAllowedInIncognito((*urls)[i], GetProfile())) {
 336         i++;
 337       } else {
 338         if (first_url_erased.empty())
 339           first_url_erased = (*urls)[i].spec();
 340         urls->erase(urls->begin() + i);
 341       }
 342     }
 343     if (urls->empty() && !first_url_erased.empty()) {
 344       error_ = ErrorUtils::FormatErrorMessage(
 345           keys::kURLsNotAllowedInIncognitoError, first_url_erased);
 346       *is_error = true;
 347       return false;
 348     }
 349   }
 350   return incognito;
 351 }
 352
 353 bool WindowsCreateFunction::RunSync() {
 354   scoped_ptr<windows::Create::Params> params(
 355       windows::Create::Params::Create(*args_));
 356   EXTENSION_FUNCTION_VALIDATE(params);
 357   std::vector<GURL> urls;
 358   TabStripModel* source_tab_strip = NULL;
 359   int tab_index = -1;
 360
 361   windows::Create::Params::CreateData* create_data = params->create_data.get();
 362
 363   // Look for optional url.
 364   if (create_data && create_data->url) {
 365     std::vector<std::string> url_strings;
 366     // First, get all the URLs the client wants to open.
 367     if (create_data->url->as_string)
 368       url_strings.push_back(*create_data->url->as_string);
 369     else if (create_data->url->as_strings)
 370       url_strings.swap(*create_data->url->as_strings);
 371
 372     // Second, resolve, validate and convert them to GURLs.
 373     for (std::vector<std::string>::iterator i = url_strings.begin();
 374          i != url_strings.end(); ++i) {
 375       GURL url = ExtensionTabUtil::ResolvePossiblyRelativeURL(*i, extension());
 376       if (!url.is_valid()) {
 377         error_ = ErrorUtils::FormatErrorMessage(keys::kInvalidUrlError, *i);
 378         return false;
 379       }
 380       // Don't let the extension crash the browser or renderers.
 381       if (ExtensionTabUtil::IsCrashURL(url)) {
 382         error_ = keys::kNoCrashBrowserError;
 383         return false;
 384       }
 385       urls.push_back(url);
 386     }
 387   }
 388
 389   // Look for optional tab id.
 390   if (create_data && create_data->tab_id) {
 391     // Find the tab. |source_tab_strip| and |tab_index| will later be used to
 392     // move the tab into the created window.
 393     if (!GetTabById(*create_data->tab_id,
 394                     GetProfile(),
 395                     include_incognito(),
 396                     NULL,
 397                     &source_tab_strip,
 398                     NULL,
 399                     &tab_index,
 400                     &error_))
 401       return false;
 402   }
 403
 404   Profile* window_profile = GetProfile();
 405   Browser::Type window_type = Browser::TYPE_TABBED;
 406   bool create_panel = false;
 407
 408   // panel_create_mode only applies if create_panel = true
 409   PanelManager::CreateMode panel_create_mode = PanelManager::CREATE_AS_DOCKED;
 410
 411   gfx::Rect window_bounds;
 412   bool focused = true;
 413   bool saw_focus_key = false;
 414   std::string extension_id;
 415
 416   // Decide whether we are opening a normal window or an incognito window.
 417   bool is_error = true;
 418   bool open_incognito_window = ShouldOpenIncognitoWindow(create_data, &urls,
 419                                                          &is_error);
 420   if (is_error) {
 421     // error_ member variable is set inside of ShouldOpenIncognitoWindow.
 422     return false;
 423   }
 424   if (open_incognito_window) {
 425     window_profile = window_profile->GetOffTheRecordProfile();
 426   }
 427
 428   if (create_data) {
 429     // Figure out window type before figuring out bounds so that default
 430     // bounds can be set according to the window type.
 431     switch (create_data->type) {
 432       case windows::Create::Params::CreateData::TYPE_POPUP:
 433         window_type = Browser::TYPE_POPUP;
 434         extension_id = extension()->id();
 435         break;
 436       case windows::Create::Params::CreateData::TYPE_PANEL:
 437       case windows::Create::Params::CreateData::TYPE_DETACHED_PANEL: {
 438         extension_id = extension()->id();
 439         bool use_panels = PanelManager::ShouldUsePanels(extension_id);
 440         if (use_panels) {
 441           create_panel = true;
 442           // Non-ash supports both docked and detached panel types.
 443           if (chrome::GetActiveDesktop() != chrome::HOST_DESKTOP_TYPE_ASH &&
 444               create_data->type ==
 445               windows::Create::Params::CreateData::TYPE_DETACHED_PANEL) {
 446             panel_create_mode = PanelManager::CREATE_AS_DETACHED;
 447           }
 448         } else {
 449           window_type = Browser::TYPE_POPUP;
 450         }
 451         break;
 452       }
 453       case windows::Create::Params::CreateData::TYPE_NONE:
 454       case windows::Create::Params::CreateData::TYPE_NORMAL:
 455         break;
 456       default:
 457         error_ = keys::kInvalidWindowTypeError;
 458         return false;
 459     }
 460
 461     // Initialize default window bounds according to window type.
 462     if (window_type == Browser::TYPE_TABBED ||
 463         window_type == Browser::TYPE_POPUP ||
 464         create_panel) {
 465       // Try to position the new browser relative to its originating
 466       // browser window. The call offsets the bounds by kWindowTilePixels
 467       // (defined in WindowSizer to be 10).
 468       //
 469       // NOTE(rafaelw): It's ok if GetCurrentBrowser() returns NULL here.
 470       // GetBrowserWindowBounds will default to saved "default" values for
 471       // the app.
 472       ui::WindowShowState show_state = ui::SHOW_STATE_DEFAULT;
 473       WindowSizer::GetBrowserWindowBoundsAndShowState(std::string(),
 474                                                       gfx::Rect(),
 475                                                       GetCurrentBrowser(),
 476                                                       &window_bounds,
 477                                                       &show_state);
 478     }
 479
 480     if (create_panel && PanelManager::CREATE_AS_DETACHED == panel_create_mode) {
 481       window_bounds.set_origin(
 482           PanelManager::GetInstance()->GetDefaultDetachedPanelOrigin());
 483     }
 484
 485     // Any part of the bounds can optionally be set by the caller.
 486     if (create_data->left)
 487       window_bounds.set_x(*create_data->left);
 488
 489     if (create_data->top)
 490       window_bounds.set_y(*create_data->top);
 491
 492     if (create_data->width)
 493       window_bounds.set_width(*create_data->width);
 494
 495     if (create_data->height)
 496       window_bounds.set_height(*create_data->height);
 497
 498     if (create_data->focused) {
 499       focused = *create_data->focused;
 500       saw_focus_key = true;
 501     }
 502   }
 503
 504   if (create_panel) {
 505     if (urls.empty())
 506       urls.push_back(GURL(chrome::kChromeUINewTabURL));
 507
 508 #if defined(USE_ASH)
 509     if (chrome::GetActiveDesktop() == chrome::HOST_DESKTOP_TYPE_ASH) {
 510       AppWindow::CreateParams create_params;
 511       create_params.window_type = AppWindow::WINDOW_TYPE_V1_PANEL;
 512       create_params.window_spec.bounds = window_bounds;
 513       create_params.focused = saw_focus_key && focused;
 514       AppWindow* app_window = new AppWindow(
 515           window_profile,
 516           new ChromeAppDelegate(make_scoped_ptr(new ScopedKeepAlive)),
 517           extension());
 518       AshPanelContents* ash_panel_contents = new AshPanelContents(app_window);
 519       app_window->Init(urls[0], ash_panel_contents, create_params);
 520       SetResult(ash_panel_contents->GetExtensionWindowController()
 521                     ->CreateWindowValueWithTabs(extension()));
 522       return true;
 523     }
 524 #endif
 525     std::string title =
 526         web_app::GenerateApplicationNameFromExtensionId(extension_id);
 527     // Note: Panels ignore all but the first url provided.
 528     Panel* panel = PanelManager::GetInstance()->CreatePanel(
 529         title, window_profile, urls[0], window_bounds, panel_create_mode);
 530
 531     // Unlike other window types, Panels do not take focus by default.
 532     if (!saw_focus_key || !focused)
 533       panel->ShowInactive();
 534     else
 535       panel->Show();
 536
 537     SetResult(panel->extension_window_controller()->CreateWindowValueWithTabs(
 538         extension()));
 539     return true;
 540   }
 541
 542   // Create a new BrowserWindow.
 543   chrome::HostDesktopType host_desktop_type = chrome::GetActiveDesktop();
 544   if (create_panel)
 545     window_type = Browser::TYPE_POPUP;
 546   Browser::CreateParams create_params(window_type, window_profile,
 547                                       host_desktop_type);
 548   if (extension_id.empty()) {
 549     create_params.initial_bounds = window_bounds;
 550   } else {
 551     create_params = Browser::CreateParams::CreateForApp(
 552         web_app::GenerateApplicationNameFromExtensionId(extension_id),
 553         false /* trusted_source */,
 554         window_bounds,
 555         window_profile,
 556         host_desktop_type);
 557   }
 558   create_params.initial_show_state = ui::SHOW_STATE_NORMAL;
 559   create_params.host_desktop_type = chrome::GetActiveDesktop();
 560
 561   Browser* new_window = new Browser(create_params);
 562
 563   for (std::vector<GURL>::iterator i = urls.begin(); i != urls.end(); ++i) {
 564     WebContents* tab = chrome::AddSelectedTabWithURL(
 565         new_window, *i, ui::PAGE_TRANSITION_LINK);
 566     if (create_panel) {
 567       TabHelper::FromWebContents(tab)->SetExtensionAppIconById(extension_id);
 568     }
 569   }
 570
 571   WebContents* contents = NULL;
 572   // Move the tab into the created window only if it's an empty popup or it's
 573   // a tabbed window.
 574   if ((window_type == Browser::TYPE_POPUP && urls.empty()) ||
 575       window_type == Browser::TYPE_TABBED) {
 576     if (source_tab_strip)
 577       contents = source_tab_strip->DetachWebContentsAt(tab_index);
 578     if (contents) {
 579       TabStripModel* target_tab_strip = new_window->tab_strip_model();
 580       target_tab_strip->InsertWebContentsAt(urls.size(), contents,
 581                                             TabStripModel::ADD_NONE);
 582     }
 583   }
 584   // Create a new tab if the created window is still empty. Don't create a new
 585   // tab when it is intended to create an empty popup.
 586   if (!contents && urls.empty() && window_type != Browser::TYPE_POPUP) {
 587     chrome::NewTab(new_window);
 588   }
 589   chrome::SelectNumberedTab(new_window, 0);
 590
 591   // Unlike other window types, Panels do not take focus by default.
 592   if (!saw_focus_key && create_panel)
 593     focused = false;
 594
 595   if (focused)
 596     new_window->window()->Show();
 597   else
 598     new_window->window()->ShowInactive();
 599
 600   if (new_window->profile()->IsOffTheRecord() &&
 601       !GetProfile()->IsOffTheRecord() && !include_incognito()) {
 602     // Don't expose incognito windows if extension itself works in non-incognito
 603     // profile and CanCrossIncognito isn't allowed.
 604     SetResult(base::Value::CreateNullValue());
 605   } else {
 606     SetResult(
 607         new_window->extension_window_controller()->CreateWindowValueWithTabs(
 608             extension()));
 609   }
 610
 611   return true;
 612 }
 613
 614 bool WindowsUpdateFunction::RunSync() {
 615   scoped_ptr<windows::Update::Params> params(
 616       windows::Update::Params::Create(*args_));
 617   EXTENSION_FUNCTION_VALIDATE(params);
 618
 619   WindowController* controller;
 620   if (!windows_util::GetWindowFromWindowID(this, params->window_id,
 621                                             &controller))
 622     return false;
 623
 624   ui::WindowShowState show_state = ui::SHOW_STATE_DEFAULT;  // No change.
 625   switch (params->update_info.state) {
 626     case windows::Update::Params::UpdateInfo::STATE_NORMAL:
 627       show_state = ui::SHOW_STATE_NORMAL;
 628       break;
 629     case windows::Update::Params::UpdateInfo::STATE_MINIMIZED:
 630       show_state = ui::SHOW_STATE_MINIMIZED;
 631       break;
 632     case windows::Update::Params::UpdateInfo::STATE_MAXIMIZED:
 633       show_state = ui::SHOW_STATE_MAXIMIZED;
 634       break;
 635     case windows::Update::Params::UpdateInfo::STATE_FULLSCREEN:
 636       show_state = ui::SHOW_STATE_FULLSCREEN;
 637       break;
 638     case windows::Update::Params::UpdateInfo::STATE_NONE:
 639       break;
 640     default:
 641       error_ = keys::kInvalidWindowStateError;
 642       return false;
 643   }
 644
 645   if (show_state != ui::SHOW_STATE_FULLSCREEN &&
 646       show_state != ui::SHOW_STATE_DEFAULT)
 647     controller->SetFullscreenMode(false, extension()->url());
 648
 649   switch (show_state) {
 650     case ui::SHOW_STATE_MINIMIZED:
 651       controller->window()->Minimize();
 652       break;
 653     case ui::SHOW_STATE_MAXIMIZED:
 654       controller->window()->Maximize();
 655       break;
 656     case ui::SHOW_STATE_FULLSCREEN:
 657       if (controller->window()->IsMinimized() ||
 658           controller->window()->IsMaximized())
 659         controller->window()->Restore();
 660       controller->SetFullscreenMode(true, extension()->url());
 661       break;
 662     case ui::SHOW_STATE_NORMAL:
 663       controller->window()->Restore();
 664       break;
 665     default:
 666       break;
 667   }
 668
 669   gfx::Rect bounds;
 670   if (controller->window()->IsMinimized())
 671     bounds = controller->window()->GetRestoredBounds();
 672   else
 673     bounds = controller->window()->GetBounds();
 674   bool set_bounds = false;
 675
 676   // Any part of the bounds can optionally be set by the caller.
 677   if (params->update_info.left) {
 678     bounds.set_x(*params->update_info.left);
 679     set_bounds = true;
 680   }
 681
 682   if (params->update_info.top) {
 683     bounds.set_y(*params->update_info.top);
 684     set_bounds = true;
 685   }
 686
 687   if (params->update_info.width) {
 688     bounds.set_width(*params->update_info.width);
 689     set_bounds = true;
 690   }
 691
 692   if (params->update_info.height) {
 693     bounds.set_height(*params->update_info.height);
 694     set_bounds = true;
 695   }
 696
 697   if (set_bounds) {
 698     if (show_state == ui::SHOW_STATE_MINIMIZED ||
 699         show_state == ui::SHOW_STATE_MAXIMIZED ||
 700         show_state == ui::SHOW_STATE_FULLSCREEN) {
 701       error_ = keys::kInvalidWindowStateError;
 702       return false;
 703     }
 704     // TODO(varkha): Updating bounds during a drag can cause problems and a more
 705     // general solution is needed. See http://crbug.com/251813 .
 706     controller->window()->SetBounds(bounds);
 707   }
 708
 709   if (params->update_info.focused) {
 710     if (*params->update_info.focused) {
 711       if (show_state == ui::SHOW_STATE_MINIMIZED) {
 712         error_ = keys::kInvalidWindowStateError;
 713         return false;
 714       }
 715       controller->window()->Activate();
 716     } else {
 717       if (show_state == ui::SHOW_STATE_MAXIMIZED ||
 718           show_state == ui::SHOW_STATE_FULLSCREEN) {
 719         error_ = keys::kInvalidWindowStateError;
 720         return false;
 721       }
 722       controller->window()->Deactivate();
 723     }
 724   }
 725
 726   if (params->update_info.draw_attention)
 727     controller->window()->FlashFrame(*params->update_info.draw_attention);
 728
 729   SetResult(controller->CreateWindowValue());
 730
 731   return true;
 732 }
 733
 734 bool WindowsRemoveFunction::RunSync() {
 735   scoped_ptr<windows::Remove::Params> params(
 736       windows::Remove::Params::Create(*args_));
 737   EXTENSION_FUNCTION_VALIDATE(params);
 738
 739   WindowController* controller;
 740   if (!windows_util::GetWindowFromWindowID(this, params->window_id,
 741                                            &controller))
 742     return false;
 743
 744   WindowController::Reason reason;
 745   if (!controller->CanClose(&reason)) {
 746     if (reason == WindowController::REASON_NOT_EDITABLE)
 747       error_ = keys::kTabStripNotEditableError;
 748     return false;
 749   }
 750   controller->window()->Close();
 751   return true;
 752 }
 753
 754 // Tabs ------------------------------------------------------------------------
 755
 756 bool TabsGetSelectedFunction::RunSync() {
 757   // windowId defaults to "current" window.
 758   int window_id = extension_misc::kCurrentWindowId;
 759
 760   scoped_ptr<tabs::GetSelected::Params> params(
 761       tabs::GetSelected::Params::Create(*args_));
 762   EXTENSION_FUNCTION_VALIDATE(params.get());
 763   if (params->window_id.get())
 764     window_id = *params->window_id;
 765
 766   Browser* browser = NULL;
 767   if (!GetBrowserFromWindowID(this, window_id, &browser))
 768     return false;
 769
 770   TabStripModel* tab_strip = browser->tab_strip_model();
 771   WebContents* contents = tab_strip->GetActiveWebContents();
 772   if (!contents) {
 773     error_ = keys::kNoSelectedTabError;
 774     return false;
 775   }
 776   SetResult(ExtensionTabUtil::CreateTabValue(
 777       contents, tab_strip, tab_strip->active_index(), extension()));
 778   return true;
 779 }
 780
 781 bool TabsGetAllInWindowFunction::RunSync() {
 782   scoped_ptr<tabs::GetAllInWindow::Params> params(
 783       tabs::GetAllInWindow::Params::Create(*args_));
 784   EXTENSION_FUNCTION_VALIDATE(params.get());
 785   // windowId defaults to "current" window.
 786   int window_id = extension_misc::kCurrentWindowId;
 787   if (params->window_id.get())
 788     window_id = *params->window_id;
 789
 790   Browser* browser = NULL;
 791   if (!GetBrowserFromWindowID(this, window_id, &browser))
 792     return false;
 793
 794   SetResult(ExtensionTabUtil::CreateTabList(browser, extension()));
 795
 796   return true;
 797 }
 798
 799 bool TabsQueryFunction::RunSync() {
 800   scoped_ptr<tabs::Query::Params> params(tabs::Query::Params::Create(*args_));
 801   EXTENSION_FUNCTION_VALIDATE(params.get());
 802
 803   bool loading_status_set = params->query_info.status !=
 804       tabs::Query::Params::QueryInfo::STATUS_NONE;
 805   bool loading = params->query_info.status ==
 806       tabs::Query::Params::QueryInfo::STATUS_LOADING;
 807
 808   URLPatternSet url_patterns;
 809   if (params->query_info.url.get()) {
 810     std::vector<std::string> url_pattern_strings;
 811     if (params->query_info.url->as_string)
 812       url_pattern_strings.push_back(*params->query_info.url->as_string);
 813     else if (params->query_info.url->as_strings)
 814       url_pattern_strings.swap(*params->query_info.url->as_strings);
 815     // It is o.k. to use URLPattern::SCHEME_ALL here because this function does
 816     // not grant access to the content of the tabs, only to seeing their URLs
 817     // and meta data.
 818     if (!url_patterns.Populate(url_pattern_strings, URLPattern::SCHEME_ALL,
 819                                true, &error_)) {
 820       return false;
 821     }
 822   }
 823
 824   std::string title;
 825   if (params->query_info.title.get())
 826     title = *params->query_info.title;
 827
 828   int window_id = extension_misc::kUnknownWindowId;
 829   if (params->query_info.window_id.get())
 830     window_id = *params->query_info.window_id;
 831
 832   int index = -1;
 833   if (params->query_info.index.get())
 834     index = *params->query_info.index;
 835
 836   std::string window_type;
 837   if (params->query_info.window_type !=
 838       tabs::Query::Params::QueryInfo::WINDOW_TYPE_NONE) {
 839     window_type = tabs::Query::Params::QueryInfo::ToString(
 840         params->query_info.window_type);
 841   }
 842
 843   base::ListValue* result = new base::ListValue();
 844   Browser* last_active_browser = chrome::FindAnyBrowser(
 845       GetProfile(), include_incognito(), chrome::GetActiveDesktop());
 846   Browser* current_browser = GetCurrentBrowser();
 847   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
 848     Browser* browser = *it;
 849     if (!GetProfile()->IsSameProfile(browser->profile()))
 850       continue;
 851
 852     if (!browser->window())
 853       continue;
 854
 855     if (!include_incognito() && GetProfile() != browser->profile())
 856       continue;
 857
 858     if (window_id >= 0 && window_id != ExtensionTabUtil::GetWindowId(browser))
 859       continue;
 860
 861     if (window_id == extension_misc::kCurrentWindowId &&
 862         browser != current_browser) {
 863       continue;
 864     }
 865
 866     if (!MatchesBool(params->query_info.current_window.get(),
 867                      browser == current_browser)) {
 868       continue;
 869     }
 870
 871     if (!MatchesBool(params->query_info.last_focused_window.get(),
 872                      browser == last_active_browser)) {
 873       continue;
 874     }
 875
 876     if (!window_type.empty() &&
 877         window_type !=
 878             browser->extension_window_controller()->GetWindowTypeText()) {
 879       continue;
 880     }
 881
 882     TabStripModel* tab_strip = browser->tab_strip_model();
 883     for (int i = 0; i < tab_strip->count(); ++i) {
 884       WebContents* web_contents = tab_strip->GetWebContentsAt(i);
 885
 886       if (index > -1 && i != index)
 887         continue;
 888
 889       if (!MatchesBool(params->query_info.highlighted.get(),
 890                        tab_strip->IsTabSelected(i))) {
 891         continue;
 892       }
 893
 894       if (!MatchesBool(params->query_info.active.get(),
 895                        i == tab_strip->active_index())) {
 896         continue;
 897       }
 898
 899       if (!MatchesBool(params->query_info.pinned.get(),
 900                        tab_strip->IsTabPinned(i))) {
 901         continue;
 902       }
 903
 904       if (!title.empty() && !MatchPattern(web_contents->GetTitle(),
 905                                           base::UTF8ToUTF16(title)))
 906         continue;
 907
 908       if (!url_patterns.is_empty() &&
 909           !url_patterns.MatchesURL(web_contents->GetURL()))
 910         continue;
 911
 912       if (loading_status_set && loading != web_contents->IsLoading())
 913         continue;
 914
 915       result->Append(ExtensionTabUtil::CreateTabValue(
 916           web_contents, tab_strip, i, extension()));
 917     }
 918   }
 919
 920   SetResult(result);
 921   return true;
 922 }
 923
 924 bool TabsCreateFunction::RunSync() {
 925   scoped_ptr<tabs::Create::Params> params(tabs::Create::Params::Create(*args_));
 926   EXTENSION_FUNCTION_VALIDATE(params.get());
 927
 928   ExtensionTabUtil::OpenTabParams options;
 929   AssignOptionalValue(params->create_properties.window_id, options.window_id);
 930   AssignOptionalValue(params->create_properties.opener_tab_id,
 931                       options.opener_tab_id);
 932   AssignOptionalValue(params->create_properties.selected, options.active);
 933   // The 'active' property has replaced the 'selected' property.
 934   AssignOptionalValue(params->create_properties.active, options.active);
 935   AssignOptionalValue(params->create_properties.pinned, options.pinned);
 936   AssignOptionalValue(params->create_properties.index, options.index);
 937   AssignOptionalValue(params->create_properties.url, options.url);
 938
 939   std::string error;
 940   scoped_ptr<base::DictionaryValue> result(
 941       ExtensionTabUtil::OpenTab(this, options, &error));
 942   if (!result) {
 943     SetError(error);
 944     return false;
 945   }
 946
 947   // Return data about the newly created tab.
 948   if (has_callback()) {
 949     SetResult(result.release());
 950   }
 951   return true;
 952 }
 953
 954 bool TabsDuplicateFunction::RunSync() {
 955   scoped_ptr<tabs::Duplicate::Params> params(
 956       tabs::Duplicate::Params::Create(*args_));
 957   EXTENSION_FUNCTION_VALIDATE(params.get());
 958   int tab_id = params->tab_id;
 959
 960   Browser* browser = NULL;
 961   TabStripModel* tab_strip = NULL;
 962   int tab_index = -1;
 963   if (!GetTabById(tab_id,
 964                   GetProfile(),
 965                   include_incognito(),
 966                   &browser,
 967                   &tab_strip,
 968                   NULL,
 969                   &tab_index,
 970                   &error_)) {
 971     return false;
 972   }
 973
 974   WebContents* new_contents = chrome::DuplicateTabAt(browser, tab_index);
 975   if (!has_callback())
 976     return true;
 977
 978   // Duplicated tab may not be in the same window as the original, so find
 979   // the window and the tab.
 980   TabStripModel* new_tab_strip = NULL;
 981   int new_tab_index = -1;
 982   ExtensionTabUtil::GetTabStripModel(new_contents,
 983                                      &new_tab_strip,
 984                                      &new_tab_index);
 985   if (!new_tab_strip || new_tab_index == -1) {
 986     return false;
 987   }
 988
 989   // Return data about the newly created tab.
 990   SetResult(ExtensionTabUtil::CreateTabValue(
 991       new_contents, new_tab_strip, new_tab_index, extension()));
 992
 993   return true;
 994 }
 995
 996 bool TabsGetFunction::RunSync() {
 997   scoped_ptr<tabs::Get::Params> params(tabs::Get::Params::Create(*args_));
 998   EXTENSION_FUNCTION_VALIDATE(params.get());
 999   int tab_id = params->tab_id;
1000
1001   TabStripModel* tab_strip = NULL;
1002   WebContents* contents = NULL;
1003   int tab_index = -1;
1004   if (!GetTabById(tab_id,
1005                   GetProfile(),
1006                   include_incognito(),
1007                   NULL,
1008                   &tab_strip,
1009                   &contents,
1010                   &tab_index,
1011                   &error_))
1012     return false;
1013
1014   SetResult(ExtensionTabUtil::CreateTabValue(
1015       contents, tab_strip, tab_index, extension()));
1016   return true;
1017 }
1018
1019 bool TabsGetCurrentFunction::RunSync() {
1020   DCHECK(dispatcher());
1021
1022   // Return the caller, if it's a tab. If not the result isn't an error but an
1023   // empty tab (hence returning true).
1024   WebContents* caller_contents =
1025       WebContents::FromRenderViewHost(render_view_host());
1026   if (caller_contents && ExtensionTabUtil::GetTabId(caller_contents) >= 0)
1027     SetResult(ExtensionTabUtil::CreateTabValue(caller_contents, extension()));
1028
1029   return true;
1030 }
1031
1032 bool TabsHighlightFunction::RunSync() {
1033   scoped_ptr<tabs::Highlight::Params> params(
1034       tabs::Highlight::Params::Create(*args_));
1035   EXTENSION_FUNCTION_VALIDATE(params.get());
1036
1037   // Get the window id from the params; default to current window if omitted.
1038   int window_id = extension_misc::kCurrentWindowId;
1039   if (params->highlight_info.window_id.get())
1040     window_id = *params->highlight_info.window_id;
1041
1042   Browser* browser = NULL;
1043   if (!GetBrowserFromWindowID(this, window_id, &browser))
1044     return false;
1045
1046   TabStripModel* tabstrip = browser->tab_strip_model();
1047   ui::ListSelectionModel selection;
1048   int active_index = -1;
1049
1050   if (params->highlight_info.tabs.as_integers) {
1051     std::vector<int>& tab_indices = *params->highlight_info.tabs.as_integers;
1052     // Create a new selection model as we read the list of tab indices.
1053     for (size_t i = 0; i < tab_indices.size(); ++i) {
1054       if (!HighlightTab(tabstrip, &selection, &active_index, tab_indices[i]))
1055         return false;
1056     }
1057   } else {
1058     EXTENSION_FUNCTION_VALIDATE(params->highlight_info.tabs.as_integer);
1059     if (!HighlightTab(tabstrip,
1060                       &selection,
1061                       &active_index,
1062                       *params->highlight_info.tabs.as_integer)) {
1063       return false;
1064     }
1065   }
1066
1067   // Make sure they actually specified tabs to select.
1068   if (selection.empty()) {
1069     error_ = keys::kNoHighlightedTabError;
1070     return false;
1071   }
1072
1073   selection.set_active(active_index);
1074   browser->tab_strip_model()->SetSelectionFromModel(selection);
1075   SetResult(browser->extension_window_controller()->CreateWindowValueWithTabs(
1076       extension()));
1077   return true;
1078 }
1079
1080 bool TabsHighlightFunction::HighlightTab(TabStripModel* tabstrip,
1081                                          ui::ListSelectionModel* selection,
1082                                          int* active_index,
1083                                          int index) {
1084   // Make sure the index is in range.
1085   if (!tabstrip->ContainsIndex(index)) {
1086     error_ = ErrorUtils::FormatErrorMessage(
1087         keys::kTabIndexNotFoundError, base::IntToString(index));
1088     return false;
1089   }
1090
1091   // By default, we make the first tab in the list active.
1092   if (*active_index == -1)
1093     *active_index = index;
1094
1095   selection->AddIndexToSelection(index);
1096   return true;
1097 }
1098
1099 TabsUpdateFunction::TabsUpdateFunction() : web_contents_(NULL) {
1100 }
1101
1102 bool TabsUpdateFunction::RunAsync() {
1103   scoped_ptr<tabs::Update::Params> params(tabs::Update::Params::Create(*args_));
1104   EXTENSION_FUNCTION_VALIDATE(params.get());
1105
1106   int tab_id = -1;
1107   WebContents* contents = NULL;
1108   if (!params->tab_id.get()) {
1109     Browser* browser = GetCurrentBrowser();
1110     if (!browser) {
1111       error_ = keys::kNoCurrentWindowError;
1112       return false;
1113     }
1114     contents = browser->tab_strip_model()->GetActiveWebContents();
1115     if (!contents) {
1116       error_ = keys::kNoSelectedTabError;
1117       return false;
1118     }
1119     tab_id = SessionTabHelper::IdForTab(contents);
1120   } else {
1121     tab_id = *params->tab_id;
1122   }
1123
1124   int tab_index = -1;
1125   TabStripModel* tab_strip = NULL;
1126   if (!GetTabById(tab_id,
1127                   GetProfile(),
1128                   include_incognito(),
1129                   NULL,
1130                   &tab_strip,
1131                   &contents,
1132                   &tab_index,
1133                   &error_)) {
1134     return false;
1135   }
1136
1137   web_contents_ = contents;
1138
1139   // TODO(rafaelw): handle setting remaining tab properties:
1140   // -title
1141   // -favIconUrl
1142
1143   // Navigate the tab to a new location if the url is different.
1144   bool is_async = false;
1145   if (params->update_properties.url.get() &&
1146       !UpdateURL(*params->update_properties.url, tab_id, &is_async)) {
1147     return false;
1148   }
1149
1150   bool active = false;
1151   // TODO(rafaelw): Setting |active| from js doesn't make much sense.
1152   // Move tab selection management up to window.
1153   if (params->update_properties.selected.get())
1154     active = *params->update_properties.selected;
1155
1156   // The 'active' property has replaced 'selected'.
1157   if (params->update_properties.active.get())
1158     active = *params->update_properties.active;
1159
1160   if (active) {
1161     if (tab_strip->active_index() != tab_index) {
1162       tab_strip->ActivateTabAt(tab_index, false);
1163       DCHECK_EQ(contents, tab_strip->GetActiveWebContents());
1164     }
1165   }
1166
1167   if (params->update_properties.highlighted.get()) {
1168     bool highlighted = *params->update_properties.highlighted;
1169     if (highlighted != tab_strip->IsTabSelected(tab_index))
1170       tab_strip->ToggleSelectionAt(tab_index);
1171   }
1172
1173   if (params->update_properties.pinned.get()) {
1174     bool pinned = *params->update_properties.pinned;
1175     tab_strip->SetTabPinned(tab_index, pinned);
1176
1177     // Update the tab index because it may move when being pinned.
1178     tab_index = tab_strip->GetIndexOfWebContents(contents);
1179   }
1180
1181   if (params->update_properties.opener_tab_id.get()) {
1182     int opener_id = *params->update_properties.opener_tab_id;
1183
1184     WebContents* opener_contents = NULL;
1185     if (!ExtensionTabUtil::GetTabById(opener_id,
1186                                       GetProfile(),
1187                                       include_incognito(),
1188                                       NULL,
1189                                       NULL,
1190                                       &opener_contents,
1191                                       NULL))
1192       return false;
1193
1194     tab_strip->SetOpenerOfWebContentsAt(tab_index, opener_contents);
1195   }
1196
1197   if (!is_async) {
1198     PopulateResult();
1199     SendResponse(true);
1200   }
1201   return true;
1202 }
1203
1204 bool TabsUpdateFunction::UpdateURL(const std::string &url_string,
1205                                    int tab_id,
1206                                    bool* is_async) {
1207   GURL url =
1208       ExtensionTabUtil::ResolvePossiblyRelativeURL(url_string, extension());
1209
1210   if (!url.is_valid()) {
1211     error_ = ErrorUtils::FormatErrorMessage(
1212         keys::kInvalidUrlError, url_string);
1213     return false;
1214   }
1215
1216   // Don't let the extension crash the browser or renderers.
1217   if (ExtensionTabUtil::IsCrashURL(url)) {
1218     error_ = keys::kNoCrashBrowserError;
1219     return false;
1220   }
1221
1222   // JavaScript URLs can do the same kinds of things as cross-origin XHR, so
1223   // we need to check host permissions before allowing them.
1224   if (url.SchemeIs(url::kJavaScriptScheme)) {
1225     content::RenderProcessHost* process = web_contents_->GetRenderProcessHost();
1226     if (!extension()->permissions_data()->CanAccessPage(
1227             extension(),
1228             web_contents_->GetURL(),
1229             web_contents_->GetURL(),
1230             tab_id,
1231             process ? process->GetID() : -1,
1232             &error_)) {
1233       return false;
1234     }
1235
1236     TabHelper::FromWebContents(web_contents_)->script_executor()->ExecuteScript(
1237         extension_id(),
1238         ScriptExecutor::JAVASCRIPT,
1239         url.GetContent(),
1240         ScriptExecutor::TOP_FRAME,
1241         ScriptExecutor::DONT_MATCH_ABOUT_BLANK,
1242         UserScript::DOCUMENT_IDLE,
1243         ScriptExecutor::MAIN_WORLD,
1244         ScriptExecutor::DEFAULT_PROCESS,
1245         GURL(),
1246         GURL(),
1247         user_gesture_,
1248         ScriptExecutor::NO_RESULT,
1249         base::Bind(&TabsUpdateFunction::OnExecuteCodeFinished, this));
1250
1251     *is_async = true;
1252     return true;
1253   }
1254
1255   web_contents_->GetController().LoadURL(
1256       url, content::Referrer(), ui::PAGE_TRANSITION_LINK, std::string());
1257
1258   // The URL of a tab contents never actually changes to a JavaScript URL, so
1259   // this check only makes sense in other cases.
1260   if (!url.SchemeIs(url::kJavaScriptScheme))
1261     DCHECK_EQ(url.spec(), web_contents_->GetURL().spec());
1262
1263   return true;
1264 }
1265
1266 void TabsUpdateFunction::PopulateResult() {
1267   if (!has_callback())
1268     return;
1269
1270   SetResult(ExtensionTabUtil::CreateTabValue(web_contents_, extension()));
1271 }
1272
1273 void TabsUpdateFunction::OnExecuteCodeFinished(
1274     const std::string& error,
1275     const GURL& url,
1276     const base::ListValue& script_result) {
1277   if (error.empty())
1278     PopulateResult();
1279   else
1280     error_ = error;
1281   SendResponse(error.empty());
1282 }
1283
1284 bool TabsMoveFunction::RunSync() {
1285   scoped_ptr<tabs::Move::Params> params(tabs::Move::Params::Create(*args_));
1286   EXTENSION_FUNCTION_VALIDATE(params.get());
1287
1288   int new_index = params->move_properties.index;
1289   int* window_id = params->move_properties.window_id.get();
1290   scoped_ptr<base::ListValue> tab_values(new base::ListValue());
1291
1292   size_t num_tabs = 0;
1293   if (params->tab_ids.as_integers) {
1294     std::vector<int>& tab_ids = *params->tab_ids.as_integers;
1295     num_tabs = tab_ids.size();
1296     for (size_t i = 0; i < tab_ids.size(); ++i) {
1297       if (!MoveTab(tab_ids[i], &new_index, i, tab_values.get(), window_id))
1298         return false;
1299     }
1300   } else {
1301     EXTENSION_FUNCTION_VALIDATE(params->tab_ids.as_integer);
1302     num_tabs = 1;
1303     if (!MoveTab(*params->tab_ids.as_integer,
1304                  &new_index,
1305                  0,
1306                  tab_values.get(),
1307                  window_id)) {
1308       return false;
1309     }
1310   }
1311
1312   if (!has_callback())
1313     return true;
1314
1315   if (num_tabs == 0) {
1316     error_ = "No tabs given.";
1317     return false;
1318   } else if (num_tabs == 1) {
1319     scoped_ptr<base::Value> value;
1320     CHECK(tab_values.get()->Remove(0, &value));
1321     SetResult(value.release());
1322   } else {
1323     // Only return the results as an array if there are multiple tabs.
1324     SetResult(tab_values.release());
1325   }
1326
1327   return true;
1328 }
1329
1330 bool TabsMoveFunction::MoveTab(int tab_id,
1331                                int* new_index,
1332                                int iteration,
1333                                base::ListValue* tab_values,
1334                                int* window_id) {
1335   Browser* source_browser = NULL;
1336   TabStripModel* source_tab_strip = NULL;
1337   WebContents* contents = NULL;
1338   int tab_index = -1;
1339   if (!GetTabById(tab_id,
1340                   GetProfile(),
1341                   include_incognito(),
1342                   &source_browser,
1343                   &source_tab_strip,
1344                   &contents,
1345                   &tab_index,
1346                   &error_)) {
1347     return false;
1348   }
1349
1350   // Don't let the extension move the tab if the user is dragging tabs.
1351   if (!source_browser->window()->IsTabStripEditable()) {
1352     error_ = keys::kTabStripNotEditableError;
1353     return false;
1354   }
1355
1356   // Insert the tabs one after another.
1357   *new_index += iteration;
1358
1359   if (window_id) {
1360     Browser* target_browser = NULL;
1361
1362     if (!GetBrowserFromWindowID(this, *window_id, &target_browser))
1363       return false;
1364
1365     if (!target_browser->window()->IsTabStripEditable()) {
1366       error_ = keys::kTabStripNotEditableError;
1367       return false;
1368     }
1369
1370     if (!target_browser->is_type_tabbed()) {
1371       error_ = keys::kCanOnlyMoveTabsWithinNormalWindowsError;
1372       return false;
1373     }
1374
1375     if (target_browser->profile() != source_browser->profile()) {
1376       error_ = keys::kCanOnlyMoveTabsWithinSameProfileError;
1377       return false;
1378     }
1379
1380     // If windowId is different from the current window, move between windows.
1381     if (ExtensionTabUtil::GetWindowId(target_browser) !=
1382         ExtensionTabUtil::GetWindowId(source_browser)) {
1383       TabStripModel* target_tab_strip = target_browser->tab_strip_model();
1384       WebContents* web_contents =
1385           source_tab_strip->DetachWebContentsAt(tab_index);
1386       if (!web_contents) {
1387         error_ = ErrorUtils::FormatErrorMessage(
1388             keys::kTabNotFoundError, base::IntToString(tab_id));
1389         return false;
1390       }
1391
1392       // Clamp move location to the last position.
1393       // This is ">" because it can append to a new index position.
1394       // -1 means set the move location to the last position.
1395       if (*new_index > target_tab_strip->count() || *new_index < 0)
1396         *new_index = target_tab_strip->count();
1397
1398       target_tab_strip->InsertWebContentsAt(
1399           *new_index, web_contents, TabStripModel::ADD_NONE);
1400
1401       if (has_callback()) {
1402         tab_values->Append(ExtensionTabUtil::CreateTabValue(
1403             web_contents, target_tab_strip, *new_index, extension()));
1404       }
1405
1406       return true;
1407     }
1408   }
1409
1410   // Perform a simple within-window move.
1411   // Clamp move location to the last position.
1412   // This is ">=" because the move must be to an existing location.
1413   // -1 means set the move location to the last position.
1414   if (*new_index >= source_tab_strip->count() || *new_index < 0)
1415     *new_index = source_tab_strip->count() - 1;
1416
1417   if (*new_index != tab_index)
1418     source_tab_strip->MoveWebContentsAt(tab_index, *new_index, false);
1419
1420   if (has_callback()) {
1421     tab_values->Append(ExtensionTabUtil::CreateTabValue(
1422         contents, source_tab_strip, *new_index, extension()));
1423   }
1424
1425   return true;
1426 }
1427
1428 bool TabsReloadFunction::RunSync() {
1429   scoped_ptr<tabs::Reload::Params> params(
1430       tabs::Reload::Params::Create(*args_));
1431   EXTENSION_FUNCTION_VALIDATE(params.get());
1432
1433   bool bypass_cache = false;
1434   if (params->reload_properties.get() &&
1435       params->reload_properties->bypass_cache.get()) {
1436     bypass_cache = *params->reload_properties->bypass_cache;
1437   }
1438
1439   content::WebContents* web_contents = NULL;
1440
1441   // If |tab_id| is specified, look for it. Otherwise default to selected tab
1442   // in the current window.
1443   if (!params->tab_id.get()) {
1444     Browser* browser = GetCurrentBrowser();
1445     if (!browser) {
1446       error_ = keys::kNoCurrentWindowError;
1447       return false;
1448     }
1449
1450     if (!ExtensionTabUtil::GetDefaultTab(browser, &web_contents, NULL))
1451       return false;
1452   } else {
1453     int tab_id = *params->tab_id;
1454
1455     Browser* browser = NULL;
1456     if (!GetTabById(tab_id,
1457                     GetProfile(),
1458                     include_incognito(),
1459                     &browser,
1460                     NULL,
1461                     &web_contents,
1462                     NULL,
1463                     &error_)) {
1464       return false;
1465     }
1466   }
1467
1468   if (web_contents->ShowingInterstitialPage()) {
1469     // This does as same as Browser::ReloadInternal.
1470     NavigationEntry* entry = web_contents->GetController().GetVisibleEntry();
1471     OpenURLParams params(entry->GetURL(), Referrer(), CURRENT_TAB,
1472                          ui::PAGE_TRANSITION_RELOAD, false);
1473     GetCurrentBrowser()->OpenURL(params);
1474   } else if (bypass_cache) {
1475     web_contents->GetController().ReloadIgnoringCache(true);
1476   } else {
1477     web_contents->GetController().Reload(true);
1478   }
1479
1480   return true;
1481 }
1482
1483 bool TabsRemoveFunction::RunSync() {
1484   scoped_ptr<tabs::Remove::Params> params(tabs::Remove::Params::Create(*args_));
1485   EXTENSION_FUNCTION_VALIDATE(params.get());
1486
1487   if (params->tab_ids.as_integers) {
1488     std::vector<int>& tab_ids = *params->tab_ids.as_integers;
1489     for (size_t i = 0; i < tab_ids.size(); ++i) {
1490       if (!RemoveTab(tab_ids[i]))
1491         return false;
1492     }
1493   } else {
1494     EXTENSION_FUNCTION_VALIDATE(params->tab_ids.as_integer);
1495     if (!RemoveTab(*params->tab_ids.as_integer.get()))
1496       return false;
1497   }
1498   return true;
1499 }
1500
1501 bool TabsRemoveFunction::RemoveTab(int tab_id) {
1502   Browser* browser = NULL;
1503   WebContents* contents = NULL;
1504   if (!GetTabById(tab_id,
1505                   GetProfile(),
1506                   include_incognito(),
1507                   &browser,
1508                   NULL,
1509                   &contents,
1510                   NULL,
1511                   &error_)) {
1512     return false;
1513   }
1514
1515   // Don't let the extension remove a tab if the user is dragging tabs around.
1516   if (!browser->window()->IsTabStripEditable()) {
1517     error_ = keys::kTabStripNotEditableError;
1518     return false;
1519   }
1520   // There's a chance that the tab is being dragged, or we're in some other
1521   // nested event loop. This code path ensures that the tab is safely closed
1522   // under such circumstances, whereas |TabStripModel::CloseWebContentsAt()|
1523   // does not.
1524   contents->Close();
1525   return true;
1526 }
1527
1528 TabsCaptureVisibleTabFunction::TabsCaptureVisibleTabFunction()
1529     : chrome_details_(this) {
1530 }
1531
1532 bool TabsCaptureVisibleTabFunction::IsScreenshotEnabled() {
1533   PrefService* service = chrome_details_.GetProfile()->GetPrefs();
1534   if (service->GetBoolean(prefs::kDisableScreenshots)) {
1535     error_ = keys::kScreenshotsDisabled;
1536     return false;
1537   }
1538   return true;
1539 }
1540
1541 WebContents* TabsCaptureVisibleTabFunction::GetWebContentsForID(int window_id) {
1542   Browser* browser = NULL;
1543   if (!GetBrowserFromWindowID(&chrome_details_, window_id, &browser))
1544     return NULL;
1545
1546   WebContents* contents = browser->tab_strip_model()->GetActiveWebContents();
1547   if (!contents) {
1548     error_ = keys::kInternalVisibleTabCaptureError;
1549     return NULL;
1550   }
1551
1552   if (!extension()->permissions_data()->CanCaptureVisiblePage(
1553           SessionTabHelper::IdForTab(contents), &error_)) {
1554     return NULL;
1555   }
1556   return contents;
1557 }
1558
1559 void TabsCaptureVisibleTabFunction::OnCaptureFailure(FailureReason reason) {
1560   error_ = keys::kInternalVisibleTabCaptureError;
1561   SendResponse(false);
1562 }
1563
1564 void TabsCaptureVisibleTabFunction::RegisterProfilePrefs(
1565     user_prefs::PrefRegistrySyncable* registry) {
1566   registry->RegisterBooleanPref(
1567       prefs::kDisableScreenshots,
1568       false,
1569       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
1570 }
1571
1572 bool TabsDetectLanguageFunction::RunAsync() {
1573   scoped_ptr<tabs::DetectLanguage::Params> params(
1574       tabs::DetectLanguage::Params::Create(*args_));
1575   EXTENSION_FUNCTION_VALIDATE(params.get());
1576
1577   int tab_id = 0;
1578   Browser* browser = NULL;
1579   WebContents* contents = NULL;
1580
1581   // If |tab_id| is specified, look for it. Otherwise default to selected tab
1582   // in the current window.
1583   if (params->tab_id.get()) {
1584     tab_id = *params->tab_id;
1585     if (!GetTabById(tab_id,
1586                     GetProfile(),
1587                     include_incognito(),
1588                     &browser,
1589                     NULL,
1590                     &contents,
1591                     NULL,
1592                     &error_)) {
1593       return false;
1594     }
1595     if (!browser || !contents)
1596       return false;
1597   } else {
1598     browser = GetCurrentBrowser();
1599     if (!browser)
1600       return false;
1601     contents = browser->tab_strip_model()->GetActiveWebContents();
1602     if (!contents)
1603       return false;
1604   }
1605
1606   if (contents->GetController().NeedsReload()) {
1607     // If the tab hasn't been loaded, don't wait for the tab to load.
1608     error_ = keys::kCannotDetermineLanguageOfUnloadedTab;
1609     return false;
1610   }
1611
1612   AddRef();  // Balanced in GotLanguage().
1613
1614   ChromeTranslateClient* chrome_translate_client =
1615       ChromeTranslateClient::FromWebContents(contents);
1616   if (!chrome_translate_client->GetLanguageState()
1617            .original_language()
1618            .empty()) {
1619     // Delay the callback invocation until after the current JS call has
1620     // returned.
1621     base::MessageLoop::current()->PostTask(
1622         FROM_HERE,
1623         base::Bind(
1624             &TabsDetectLanguageFunction::GotLanguage,
1625             this,
1626             chrome_translate_client->GetLanguageState().original_language()));
1627     return true;
1628   }
1629   // The tab contents does not know its language yet.  Let's wait until it
1630   // receives it, or until the tab is closed/navigates to some other page.
1631   registrar_.Add(this, chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED,
1632                  content::Source<WebContents>(contents));
1633   registrar_.Add(
1634       this, chrome::NOTIFICATION_TAB_CLOSING,
1635       content::Source<NavigationController>(&(contents->GetController())));
1636   registrar_.Add(
1637       this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
1638       content::Source<NavigationController>(&(contents->GetController())));
1639   return true;
1640 }
1641
1642 void TabsDetectLanguageFunction::Observe(
1643     int type,
1644     const content::NotificationSource& source,
1645     const content::NotificationDetails& details) {
1646   std::string language;
1647   if (type == chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED) {
1648     const translate::LanguageDetectionDetails* lang_det_details =
1649         content::Details<const translate::LanguageDetectionDetails>(details)
1650             .ptr();
1651     language = lang_det_details->adopted_language;
1652   }
1653
1654   registrar_.RemoveAll();
1655
1656   // Call GotLanguage in all cases as we want to guarantee the callback is
1657   // called for every API call the extension made.
1658   GotLanguage(language);
1659 }
1660
1661 void TabsDetectLanguageFunction::GotLanguage(const std::string& language) {
1662   SetResult(new base::StringValue(language.c_str()));
1663   SendResponse(true);
1664
1665   Release();  // Balanced in Run()
1666 }
1667
1668 ExecuteCodeInTabFunction::ExecuteCodeInTabFunction()
1669     : chrome_details_(this), execute_tab_id_(-1) {
1670 }
1671
1672 ExecuteCodeInTabFunction::~ExecuteCodeInTabFunction() {}
1673
1674 bool ExecuteCodeInTabFunction::HasPermission() {
1675   if (Init() &&
1676       extension_->permissions_data()->HasAPIPermissionForTab(
1677           execute_tab_id_, APIPermission::kTab)) {
1678     return true;
1679   }
1680   return ExtensionFunction::HasPermission();
1681 }
1682
1683 bool ExecuteCodeInTabFunction::Init() {
1684   if (details_.get())
1685     return true;
1686
1687   // |tab_id| is optional so it's ok if it's not there.
1688   int tab_id = -1;
1689   if (args_->GetInteger(0, &tab_id))
1690     EXTENSION_FUNCTION_VALIDATE(tab_id >= 0);
1691
1692   // |details| are not optional.
1693   base::DictionaryValue* details_value = NULL;
1694   if (!args_->GetDictionary(1, &details_value))
1695     return false;
1696   scoped_ptr<InjectDetails> details(new InjectDetails());
1697   if (!InjectDetails::Populate(*details_value, details.get()))
1698     return false;
1699
1700   // If the tab ID wasn't given then it needs to be converted to the
1701   // currently active tab's ID.
1702   if (tab_id == -1) {
1703     Browser* browser = chrome_details_.GetCurrentBrowser();
1704     if (!browser)
1705       return false;
1706     content::WebContents* web_contents = NULL;
1707     if (!ExtensionTabUtil::GetDefaultTab(browser, &web_contents, &tab_id))
1708       return false;
1709   }
1710
1711   execute_tab_id_ = tab_id;
1712   details_ = details.Pass();
1713   return true;
1714 }
1715
1716 bool ExecuteCodeInTabFunction::CanExecuteScriptOnPage() {
1717   content::WebContents* contents = NULL;
1718
1719   // If |tab_id| is specified, look for the tab. Otherwise default to selected
1720   // tab in the current window.
1721   CHECK_GE(execute_tab_id_, 0);
1722   if (!GetTabById(execute_tab_id_,
1723                   chrome_details_.GetProfile(),
1724                   include_incognito(),
1725                   NULL,
1726                   NULL,
1727                   &contents,
1728                   NULL,
1729                   &error_)) {
1730     return false;
1731   }
1732
1733   CHECK(contents);
1734
1735   // NOTE: This can give the wrong answer due to race conditions, but it is OK,
1736   // we check again in the renderer.
1737   content::RenderProcessHost* process = contents->GetRenderProcessHost();
1738   if (!extension()->permissions_data()->CanAccessPage(
1739           extension(),
1740           contents->GetURL(),
1741           contents->GetURL(),
1742           execute_tab_id_,
1743           process ? process->GetID() : -1,
1744           &error_)) {
1745     return false;
1746   }
1747
1748   return true;
1749 }
1750
1751 ScriptExecutor* ExecuteCodeInTabFunction::GetScriptExecutor() {
1752   Browser* browser = NULL;
1753   content::WebContents* contents = NULL;
1754
1755   bool success = GetTabById(execute_tab_id_,
1756                             chrome_details_.GetProfile(),
1757                             include_incognito(),
1758                             &browser,
1759                             NULL,
1760                             &contents,
1761                             NULL,
1762                             &error_) &&
1763                  contents && browser;
1764
1765   if (!success)
1766     return NULL;
1767
1768   return TabHelper::FromWebContents(contents)->script_executor();
1769 }
1770
1771 bool ExecuteCodeInTabFunction::IsWebView() const {
1772   return false;
1773 }
1774
1775 const GURL& ExecuteCodeInTabFunction::GetWebViewSrc() const {
1776   return GURL::EmptyGURL();
1777 }
1778
1779 bool TabsExecuteScriptFunction::ShouldInsertCSS() const {
1780   return false;
1781 }
1782
1783 void TabsExecuteScriptFunction::OnExecuteCodeFinished(
1784     const std::string& error,
1785     const GURL& on_url,
1786     const base::ListValue& result) {
1787   if (error.empty())
1788     SetResult(result.DeepCopy());
1789   ExecuteCodeInTabFunction::OnExecuteCodeFinished(error, on_url, result);
1790 }
1791
1792 bool TabsInsertCSSFunction::ShouldInsertCSS() const {
1793   return true;
1794 }
1795
1796 content::WebContents* ZoomAPIFunction::GetWebContents(int tab_id) {
1797   content::WebContents* web_contents = NULL;
1798   if (tab_id != -1) {
1799     // We assume this call leaves web_contents unchanged if it is unsuccessful.
1800     GetTabById(tab_id,
1801                GetProfile(),
1802                include_incognito(),
1803                NULL /* ignore Browser* output */,
1804                NULL /* ignore TabStripModel* output */,
1805                &web_contents,
1806                NULL /* ignore int tab_index output */,
1807                &error_);
1808   } else {
1809     Browser* browser = GetCurrentBrowser();
1810     if (!browser)
1811       error_ = keys::kNoCurrentWindowError;
1812     else if (!ExtensionTabUtil::GetDefaultTab(browser, &web_contents, NULL))
1813       error_ = keys::kNoSelectedTabError;
1814   }
1815   return web_contents;
1816 }
1817
1818 bool TabsSetZoomFunction::RunAsync() {
1819   scoped_ptr<tabs::SetZoom::Params> params(
1820       tabs::SetZoom::Params::Create(*args_));
1821   EXTENSION_FUNCTION_VALIDATE(params);
1822
1823   int tab_id = params->tab_id ? *params->tab_id : -1;
1824   WebContents* web_contents = GetWebContents(tab_id);
1825   if (!web_contents)
1826     return false;
1827
1828   GURL url(web_contents->GetVisibleURL());
1829   if (PermissionsData::IsRestrictedUrl(url, url, extension(), &error_))
1830     return false;
1831
1832   ZoomController* zoom_controller =
1833       ZoomController::FromWebContents(web_contents);
1834   double zoom_level = content::ZoomFactorToZoomLevel(params->zoom_factor);
1835
1836   if (!zoom_controller->SetZoomLevelByExtension(zoom_level, extension())) {
1837     // Tried to zoom a tab in disabled mode.
1838     error_ = keys::kCannotZoomDisabledTabError;
1839     return false;
1840   }
1841
1842   SendResponse(true);
1843   return true;
1844 }
1845
1846 bool TabsGetZoomFunction::RunAsync() {
1847   scoped_ptr<tabs::GetZoom::Params> params(
1848       tabs::GetZoom::Params::Create(*args_));
1849   EXTENSION_FUNCTION_VALIDATE(params);
1850
1851   int tab_id = params->tab_id ? *params->tab_id : -1;
1852   WebContents* web_contents = GetWebContents(tab_id);
1853   if (!web_contents)
1854     return false;
1855
1856   double zoom_level =
1857       ZoomController::FromWebContents(web_contents)->GetZoomLevel();
1858   double zoom_factor = content::ZoomLevelToZoomFactor(zoom_level);
1859   results_ = tabs::GetZoom::Results::Create(zoom_factor);
1860   SendResponse(true);
1861   return true;
1862 }
1863
1864 bool TabsSetZoomSettingsFunction::RunAsync() {
1865   using api::tabs::ZoomSettings;
1866
1867   scoped_ptr<tabs::SetZoomSettings::Params> params(
1868       tabs::SetZoomSettings::Params::Create(*args_));
1869   EXTENSION_FUNCTION_VALIDATE(params);
1870
1871   int tab_id = params->tab_id ? *params->tab_id : -1;
1872   WebContents* web_contents = GetWebContents(tab_id);
1873   if (!web_contents)
1874     return false;
1875
1876   GURL url(web_contents->GetVisibleURL());
1877   if (PermissionsData::IsRestrictedUrl(url, url, extension(), &error_))
1878     return false;
1879
1880   // "per-origin" scope is only available in "automatic" mode.
1881   if (params->zoom_settings.scope == ZoomSettings::SCOPE_PER_ORIGIN &&
1882       params->zoom_settings.mode != ZoomSettings::MODE_AUTOMATIC &&
1883       params->zoom_settings.mode != ZoomSettings::MODE_NONE) {
1884     error_ = keys::kPerOriginOnlyInAutomaticError;
1885     return false;
1886   }
1887
1888   // Determine the correct internal zoom mode to set |web_contents| to from the
1889   // user-specified |zoom_settings|.
1890   ZoomController::ZoomMode zoom_mode = ZoomController::ZOOM_MODE_DEFAULT;
1891   switch (params->zoom_settings.mode) {
1892     case ZoomSettings::MODE_NONE:
1893     case ZoomSettings::MODE_AUTOMATIC:
1894       switch (params->zoom_settings.scope) {
1895         case ZoomSettings::SCOPE_NONE:
1896         case ZoomSettings::SCOPE_PER_ORIGIN:
1897           zoom_mode = ZoomController::ZOOM_MODE_DEFAULT;
1898           break;
1899         case ZoomSettings::SCOPE_PER_TAB:
1900           zoom_mode = ZoomController::ZOOM_MODE_ISOLATED;
1901       }
1902       break;
1903     case ZoomSettings::MODE_MANUAL:
1904       zoom_mode = ZoomController::ZOOM_MODE_MANUAL;
1905       break;
1906     case ZoomSettings::MODE_DISABLED:
1907       zoom_mode = ZoomController::ZOOM_MODE_DISABLED;
1908   }
1909
1910   ZoomController::FromWebContents(web_contents)->SetZoomMode(zoom_mode);
1911
1912   SendResponse(true);
1913   return true;
1914 }
1915
1916 bool TabsGetZoomSettingsFunction::RunAsync() {
1917   scoped_ptr<tabs::GetZoomSettings::Params> params(
1918       tabs::GetZoomSettings::Params::Create(*args_));
1919   EXTENSION_FUNCTION_VALIDATE(params);
1920
1921   int tab_id = params->tab_id ? *params->tab_id : -1;
1922   WebContents* web_contents = GetWebContents(tab_id);
1923   if (!web_contents)
1924     return false;
1925   ZoomController* zoom_controller =
1926       ZoomController::FromWebContents(web_contents);
1927
1928   ZoomController::ZoomMode zoom_mode = zoom_controller->zoom_mode();
1929   api::tabs::ZoomSettings zoom_settings;
1930   ZoomModeToZoomSettings(zoom_mode, &zoom_settings);
1931
1932   results_ = api::tabs::GetZoomSettings::Results::Create(zoom_settings);
1933   SendResponse(true);
1934   return true;
1935 }
1936
1937 }  // namespace extensions