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 1938
