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 6 #include <string> 7 8 #include "base/memory/ref_counted.h" 9 #include "base/memory/scoped_ptr.h" 10 #include "base/prefs/pref_service.h" 11 #include "base/strings/string_util.h" 12 #include "base/strings/stringprintf.h" 13 #include "base/values.h" 14 #include "chrome/browser/extensions/api/tabs/tabs_api.h" 15 #include "chrome/browser/extensions/api/tabs/tabs_constants.h" 16 #include "chrome/browser/extensions/extension_function_test_utils.h" 17 #include "chrome/browser/extensions/extension_tab_util.h" 18 #include "chrome/browser/prefs/incognito_mode_prefs.h" 19 #include "chrome/browser/profiles/profile.h" 20 #include "chrome/browser/ui/browser.h" 21 #include "chrome/browser/ui/browser_commands.h" 22 #include "chrome/browser/ui/browser_window.h" 23 #include "chrome/test/base/in_process_browser_test.h" 24 #include "chrome/test/base/ui_test_utils.h" 25 #include "content/public/common/url_constants.h" 26 #include "ui/gfx/rect.h" 27 28 namespace extensions { 29 30 namespace keys = tabs_constants; 31 namespace utils = extension_function_test_utils; 32 33 namespace { 34 35 class ExtensionTabsTest : public InProcessBrowserTest { 36 }; 37 38 } 39 40 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, GetWindow) { 41 int window_id = ExtensionTabUtil::GetWindowId(browser()); 42 43 // Invalid window ID error. 44 scoped_refptr<WindowsGetFunction> function = new WindowsGetFunction(); 45 scoped_refptr<Extension> extension(utils::CreateEmptyExtension()); 46 function->set_extension(extension.get()); 47 EXPECT_TRUE(MatchPattern( 48 utils::RunFunctionAndReturnError( 49 function.get(), 50 base::StringPrintf("[%u]", window_id + 1), 51 browser()), 52 keys::kWindowNotFoundError)); 53 54 // Basic window details. 55 gfx::Rect bounds; 56 if (browser()->window()->IsMinimized()) 57 bounds = browser()->window()->GetRestoredBounds(); 58 else 59 bounds = browser()->window()->GetBounds(); 60 61 function = new WindowsGetFunction(); 62 function->set_extension(extension.get()); 63 scoped_ptr<base::DictionaryValue> result(utils::ToDictionary( 64 utils::RunFunctionAndReturnSingleResult( 65 function.get(), 66 base::StringPrintf("[%u]", window_id), 67 browser()))); 68 EXPECT_EQ(window_id, utils::GetInteger(result.get(), "id")); 69 EXPECT_FALSE(utils::GetBoolean(result.get(), "incognito")); 70 EXPECT_EQ("normal", utils::GetString(result.get(), "type")); 71 EXPECT_EQ(bounds.x(), utils::GetInteger(result.get(), "left")); 72 EXPECT_EQ(bounds.y(), utils::GetInteger(result.get(), "top")); 73 EXPECT_EQ(bounds.width(), utils::GetInteger(result.get(), "width")); 74 EXPECT_EQ(bounds.height(), utils::GetInteger(result.get(), "height")); 75 76 // With "populate" enabled. 77 function = new WindowsGetFunction(); 78 function->set_extension(extension.get()); 79 result.reset(utils::ToDictionary( 80 utils::RunFunctionAndReturnSingleResult( 81 function.get(), 82 base::StringPrintf("[%u, {\"populate\": true}]", window_id), 83 browser()))); 84 85 EXPECT_EQ(window_id, utils::GetInteger(result.get(), "id")); 86 // "populate" was enabled so tabs should be populated. 87 base::ListValue* tabs = NULL; 88 EXPECT_TRUE(result.get()->GetList(keys::kTabsKey, &tabs)); 89 90 // TODO(aa): Can't assume window is focused. On mac, calling Activate() from a 91 // browser test doesn't seem to do anything, so can't test the opposite 92 // either. 93 EXPECT_EQ(browser()->window()->IsActive(), 94 utils::GetBoolean(result.get(), "focused")); 95 96 // TODO(aa): Minimized and maximized dimensions. Is there a way to set 97 // minimize/maximize programmatically? 98 99 // Popup. 100 Browser* popup_browser = new Browser( 101 Browser::CreateParams(Browser::TYPE_POPUP, browser()->profile(), 102 browser()->host_desktop_type())); 103 function = new WindowsGetFunction(); 104 function->set_extension(extension.get()); 105 result.reset(utils::ToDictionary( 106 utils::RunFunctionAndReturnSingleResult( 107 function.get(), 108 base::StringPrintf( 109 "[%u]", ExtensionTabUtil::GetWindowId(popup_browser)), 110 browser()))); 111 EXPECT_EQ("popup", utils::GetString(result.get(), "type")); 112 113 // Incognito. 114 Browser* incognito_browser = CreateIncognitoBrowser(); 115 int incognito_window_id = ExtensionTabUtil::GetWindowId(incognito_browser); 116 117 // Without "include_incognito". 118 function = new WindowsGetFunction(); 119 function->set_extension(extension.get()); 120 EXPECT_TRUE(MatchPattern( 121 utils::RunFunctionAndReturnError( 122 function.get(), 123 base::StringPrintf("[%u]", incognito_window_id), 124 browser()), 125 keys::kWindowNotFoundError)); 126 127 // With "include_incognito". 128 function = new WindowsGetFunction(); 129 function->set_extension(extension.get()); 130 result.reset(utils::ToDictionary( 131 utils::RunFunctionAndReturnSingleResult( 132 function.get(), 133 base::StringPrintf("[%u]", incognito_window_id), 134 browser(), 135 utils::INCLUDE_INCOGNITO))); 136 EXPECT_TRUE(utils::GetBoolean(result.get(), "incognito")); 137 } 138 139 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, GetCurrentWindow) { 140 int window_id = ExtensionTabUtil::GetWindowId(browser()); 141 Browser* new_browser = CreateBrowser(browser()->profile()); 142 int new_id = ExtensionTabUtil::GetWindowId(new_browser); 143 144 // Get the current window using new_browser. 145 scoped_refptr<WindowsGetCurrentFunction> function = 146 new WindowsGetCurrentFunction(); 147 scoped_refptr<Extension> extension(utils::CreateEmptyExtension()); 148 function->set_extension(extension.get()); 149 scoped_ptr<base::DictionaryValue> result(utils::ToDictionary( 150 utils::RunFunctionAndReturnSingleResult(function.get(), 151 "[]", 152 new_browser))); 153 154 // The id should match the window id of the browser instance that was passed 155 // to RunFunctionAndReturnSingleResult. 156 EXPECT_EQ(new_id, utils::GetInteger(result.get(), "id")); 157 base::ListValue* tabs = NULL; 158 EXPECT_FALSE(result.get()->GetList(keys::kTabsKey, &tabs)); 159 160 // Get the current window using the old window and make the tabs populated. 161 function = new WindowsGetCurrentFunction(); 162 function->set_extension(extension.get()); 163 result.reset(utils::ToDictionary( 164 utils::RunFunctionAndReturnSingleResult(function.get(), 165 "[{\"populate\": true}]", 166 browser()))); 167 168 // The id should match the window id of the browser instance that was passed 169 // to RunFunctionAndReturnSingleResult. 170 EXPECT_EQ(window_id, utils::GetInteger(result.get(), "id")); 171 // "populate" was enabled so tabs should be populated. 172 EXPECT_TRUE(result.get()->GetList(keys::kTabsKey, &tabs)); 173 } 174 175 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, GetAllWindows) { 176 const size_t NUM_WINDOWS = 5; 177 std::set<int> window_ids; 178 std::set<int> result_ids; 179 window_ids.insert(ExtensionTabUtil::GetWindowId(browser())); 180 181 for (size_t i = 0; i < NUM_WINDOWS - 1; ++i) { 182 Browser* new_browser = CreateBrowser(browser()->profile()); 183 window_ids.insert(ExtensionTabUtil::GetWindowId(new_browser)); 184 } 185 186 scoped_refptr<WindowsGetAllFunction> function = new WindowsGetAllFunction(); 187 scoped_refptr<Extension> extension(utils::CreateEmptyExtension()); 188 function->set_extension(extension.get()); 189 scoped_ptr<base::ListValue> result(utils::ToList( 190 utils::RunFunctionAndReturnSingleResult(function.get(), 191 "[]", 192 browser()))); 193 194 base::ListValue* windows = result.get(); 195 EXPECT_EQ(NUM_WINDOWS, windows->GetSize()); 196 for (size_t i = 0; i < NUM_WINDOWS; ++i) { 197 base::DictionaryValue* result_window = NULL; 198 EXPECT_TRUE(windows->GetDictionary(i, &result_window)); 199 result_ids.insert(utils::GetInteger(result_window, "id")); 200 201 // "populate" was not passed in so tabs are not populated. 202 base::ListValue* tabs = NULL; 203 EXPECT_FALSE(result_window->GetList(keys::kTabsKey, &tabs)); 204 } 205 // The returned ids should contain all the current browser instance ids. 206 EXPECT_EQ(window_ids, result_ids); 207 208 result_ids.clear(); 209 function = new WindowsGetAllFunction(); 210 function->set_extension(extension.get()); 211 result.reset(utils::ToList( 212 utils::RunFunctionAndReturnSingleResult(function.get(), 213 "[{\"populate\": true}]", 214 browser()))); 215 216 windows = result.get(); 217 EXPECT_EQ(NUM_WINDOWS, windows->GetSize()); 218 for (size_t i = 0; i < windows->GetSize(); ++i) { 219 base::DictionaryValue* result_window = NULL; 220 EXPECT_TRUE(windows->GetDictionary(i, &result_window)); 221 result_ids.insert(utils::GetInteger(result_window, "id")); 222 223 // "populate" was enabled so tabs should be populated. 224 base::ListValue* tabs = NULL; 225 EXPECT_TRUE(result_window->GetList(keys::kTabsKey, &tabs)); 226 } 227 // The returned ids should contain all the current browser instance ids. 228 EXPECT_EQ(window_ids, result_ids); 229 } 230 231 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, UpdateNoPermissions) { 232 // The test empty extension has no permissions, therefore it should not get 233 // tab data in the function result. 234 scoped_refptr<TabsUpdateFunction> update_tab_function( 235 new TabsUpdateFunction()); 236 scoped_refptr<Extension> empty_extension(utils::CreateEmptyExtension()); 237 update_tab_function->set_extension(empty_extension.get()); 238 // Without a callback the function will not generate a result. 239 update_tab_function->set_has_callback(true); 240 241 scoped_ptr<base::DictionaryValue> result(utils::ToDictionary( 242 utils::RunFunctionAndReturnSingleResult( 243 update_tab_function.get(), 244 "[null, {\"url\": \"about:blank\", \"pinned\": true}]", 245 browser()))); 246 // The url is stripped since the extension does not have tab permissions. 247 EXPECT_FALSE(result->HasKey("url")); 248 EXPECT_TRUE(utils::GetBoolean(result.get(), "pinned")); 249 } 250 251 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, 252 DefaultToIncognitoWhenItIsForced) { 253 static const char kArgsWithoutExplicitIncognitoParam[] = 254 "[{\"url\": \"about:blank\"}]"; 255 // Force Incognito mode. 256 IncognitoModePrefs::SetAvailability(browser()->profile()->GetPrefs(), 257 IncognitoModePrefs::FORCED); 258 // Run without an explicit "incognito" param. 259 scoped_refptr<WindowsCreateFunction> function(new WindowsCreateFunction()); 260 scoped_refptr<Extension> extension(utils::CreateEmptyExtension()); 261 function->set_extension(extension.get()); 262 scoped_ptr<base::DictionaryValue> result(utils::ToDictionary( 263 utils::RunFunctionAndReturnSingleResult( 264 function.get(), 265 kArgsWithoutExplicitIncognitoParam, 266 browser(), 267 utils::INCLUDE_INCOGNITO))); 268 269 // Make sure it is a new(different) window. 270 EXPECT_NE(ExtensionTabUtil::GetWindowId(browser()), 271 utils::GetInteger(result.get(), "id")); 272 // ... and it is incognito. 273 EXPECT_TRUE(utils::GetBoolean(result.get(), "incognito")); 274 275 // Now try creating a window from incognito window. 276 Browser* incognito_browser = CreateIncognitoBrowser(); 277 // Run without an explicit "incognito" param. 278 function = new WindowsCreateFunction(); 279 function->set_extension(extension.get()); 280 result.reset(utils::ToDictionary( 281 utils::RunFunctionAndReturnSingleResult( 282 function.get(), 283 kArgsWithoutExplicitIncognitoParam, 284 incognito_browser, 285 utils::INCLUDE_INCOGNITO))); 286 // Make sure it is a new(different) window. 287 EXPECT_NE(ExtensionTabUtil::GetWindowId(incognito_browser), 288 utils::GetInteger(result.get(), "id")); 289 // ... and it is incognito. 290 EXPECT_TRUE(utils::GetBoolean(result.get(), "incognito")); 291 } 292 293 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, 294 DefaultToIncognitoWhenItIsForcedAndNoArgs) { 295 static const char kEmptyArgs[] = "[]"; 296 // Force Incognito mode. 297 IncognitoModePrefs::SetAvailability(browser()->profile()->GetPrefs(), 298 IncognitoModePrefs::FORCED); 299 // Run without an explicit "incognito" param. 300 scoped_refptr<WindowsCreateFunction> function = new WindowsCreateFunction(); 301 scoped_refptr<Extension> extension(utils::CreateEmptyExtension()); 302 function->set_extension(extension.get()); 303 scoped_ptr<base::DictionaryValue> result(utils::ToDictionary( 304 utils::RunFunctionAndReturnSingleResult(function.get(), 305 kEmptyArgs, 306 browser(), 307 utils::INCLUDE_INCOGNITO))); 308 309 // Make sure it is a new(different) window. 310 EXPECT_NE(ExtensionTabUtil::GetWindowId(browser()), 311 utils::GetInteger(result.get(), "id")); 312 // ... and it is incognito. 313 EXPECT_TRUE(utils::GetBoolean(result.get(), "incognito")); 314 315 // Now try creating a window from incognito window. 316 Browser* incognito_browser = CreateIncognitoBrowser(); 317 // Run without an explicit "incognito" param. 318 function = new WindowsCreateFunction(); 319 function->set_extension(extension.get()); 320 result.reset(utils::ToDictionary( 321 utils::RunFunctionAndReturnSingleResult(function.get(), 322 kEmptyArgs, 323 incognito_browser, 324 utils::INCLUDE_INCOGNITO))); 325 // Make sure it is a new(different) window. 326 EXPECT_NE(ExtensionTabUtil::GetWindowId(incognito_browser), 327 utils::GetInteger(result.get(), "id")); 328 // ... and it is incognito. 329 EXPECT_TRUE(utils::GetBoolean(result.get(), "incognito")); 330 } 331 332 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, 333 DontCreateNormalWindowWhenIncognitoForced) { 334 static const char kArgsWithExplicitIncognitoParam[] = 335 "[{\"url\": \"about:blank\", \"incognito\": false }]"; 336 // Force Incognito mode. 337 IncognitoModePrefs::SetAvailability(browser()->profile()->GetPrefs(), 338 IncognitoModePrefs::FORCED); 339 340 // Run with an explicit "incognito" param. 341 scoped_refptr<WindowsCreateFunction> function = new WindowsCreateFunction(); 342 scoped_refptr<Extension> extension(utils::CreateEmptyExtension()); 343 function->set_extension(extension.get()); 344 EXPECT_TRUE(MatchPattern( 345 utils::RunFunctionAndReturnError(function.get(), 346 kArgsWithExplicitIncognitoParam, 347 browser()), 348 keys::kIncognitoModeIsForced)); 349 350 // Now try opening a normal window from incognito window. 351 Browser* incognito_browser = CreateIncognitoBrowser(); 352 // Run with an explicit "incognito" param. 353 function = new WindowsCreateFunction(); 354 function->set_extension(extension.get()); 355 EXPECT_TRUE(MatchPattern( 356 utils::RunFunctionAndReturnError(function.get(), 357 kArgsWithExplicitIncognitoParam, 358 incognito_browser), 359 keys::kIncognitoModeIsForced)); 360 } 361 362 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, 363 DontCreateIncognitoWindowWhenIncognitoDisabled) { 364 static const char kArgs[] = 365 "[{\"url\": \"about:blank\", \"incognito\": true }]"; 366 367 Browser* incognito_browser = CreateIncognitoBrowser(); 368 // Disable Incognito mode. 369 IncognitoModePrefs::SetAvailability(browser()->profile()->GetPrefs(), 370 IncognitoModePrefs::DISABLED); 371 // Run in normal window. 372 scoped_refptr<WindowsCreateFunction> function = new WindowsCreateFunction(); 373 scoped_refptr<Extension> extension(utils::CreateEmptyExtension()); 374 function->set_extension(extension.get()); 375 EXPECT_TRUE(MatchPattern( 376 utils::RunFunctionAndReturnError(function.get(), 377 kArgs, 378 browser()), 379 keys::kIncognitoModeIsDisabled)); 380 381 // Run in incognito window. 382 function = new WindowsCreateFunction(); 383 function->set_extension(extension.get()); 384 EXPECT_TRUE(MatchPattern( 385 utils::RunFunctionAndReturnError(function.get(), 386 kArgs, 387 incognito_browser), 388 keys::kIncognitoModeIsDisabled)); 389 } 390 391 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, QueryCurrentWindowTabs) { 392 const size_t kExtraWindows = 3; 393 for (size_t i = 0; i < kExtraWindows; ++i) 394 CreateBrowser(browser()->profile()); 395 396 GURL url(url::kAboutBlankURL); 397 AddTabAtIndexToBrowser(browser(), 0, url, content::PAGE_TRANSITION_LINK); 398 int window_id = ExtensionTabUtil::GetWindowId(browser()); 399 400 // Get tabs in the 'current' window called from non-focused browser. 401 scoped_refptr<TabsQueryFunction> function = new TabsQueryFunction(); 402 function->set_extension(utils::CreateEmptyExtension().get()); 403 scoped_ptr<base::ListValue> result(utils::ToList( 404 utils::RunFunctionAndReturnSingleResult(function.get(), 405 "[{\"currentWindow\":true}]", 406 browser()))); 407 408 base::ListValue* result_tabs = result.get(); 409 // We should have one initial tab and one added tab. 410 EXPECT_EQ(2u, result_tabs->GetSize()); 411 for (size_t i = 0; i < result_tabs->GetSize(); ++i) { 412 base::DictionaryValue* result_tab = NULL; 413 EXPECT_TRUE(result_tabs->GetDictionary(i, &result_tab)); 414 EXPECT_EQ(window_id, utils::GetInteger(result_tab, keys::kWindowIdKey)); 415 } 416 417 // Get tabs NOT in the 'current' window called from non-focused browser. 418 function = new TabsQueryFunction(); 419 function->set_extension(utils::CreateEmptyExtension().get()); 420 result.reset(utils::ToList( 421 utils::RunFunctionAndReturnSingleResult(function.get(), 422 "[{\"currentWindow\":false}]", 423 browser()))); 424 425 result_tabs = result.get(); 426 // We should have one tab for each extra window. 427 EXPECT_EQ(kExtraWindows, result_tabs->GetSize()); 428 for (size_t i = 0; i < kExtraWindows; ++i) { 429 base::DictionaryValue* result_tab = NULL; 430 EXPECT_TRUE(result_tabs->GetDictionary(i, &result_tab)); 431 EXPECT_NE(window_id, utils::GetInteger(result_tab, keys::kWindowIdKey)); 432 } 433 } 434 435 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, DontCreateTabInClosingPopupWindow) { 436 // Test creates new popup window, closes it right away and then tries to open 437 // a new tab in it. Tab should not be opened in the popup window, but in a 438 // tabbed browser window. 439 Browser* popup_browser = new Browser( 440 Browser::CreateParams(Browser::TYPE_POPUP, browser()->profile(), 441 browser()->host_desktop_type())); 442 int window_id = ExtensionTabUtil::GetWindowId(popup_browser); 443 chrome::CloseWindow(popup_browser); 444 445 scoped_refptr<TabsCreateFunction> create_tab_function( 446 new TabsCreateFunction()); 447 create_tab_function->set_extension(utils::CreateEmptyExtension().get()); 448 // Without a callback the function will not generate a result. 449 create_tab_function->set_has_callback(true); 450 451 static const char kNewBlankTabArgs[] = 452 "[{\"url\": \"about:blank\", \"windowId\": %u}]"; 453 454 scoped_ptr<base::DictionaryValue> result(utils::ToDictionary( 455 utils::RunFunctionAndReturnSingleResult( 456 create_tab_function.get(), 457 base::StringPrintf(kNewBlankTabArgs, window_id), 458 browser()))); 459 460 EXPECT_NE(window_id, utils::GetInteger(result.get(), "windowId")); 461 } 462 463 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, InvalidUpdateWindowState) { 464 int window_id = ExtensionTabUtil::GetWindowId(browser()); 465 466 static const char kArgsMinimizedWithFocus[] = 467 "[%u, {\"state\": \"minimized\", \"focused\": true}]"; 468 scoped_refptr<WindowsUpdateFunction> function = new WindowsUpdateFunction(); 469 scoped_refptr<Extension> extension(utils::CreateEmptyExtension()); 470 function->set_extension(extension.get()); 471 EXPECT_TRUE(MatchPattern( 472 utils::RunFunctionAndReturnError( 473 function.get(), 474 base::StringPrintf(kArgsMinimizedWithFocus, window_id), 475 browser()), 476 keys::kInvalidWindowStateError)); 477 478 static const char kArgsMaximizedWithoutFocus[] = 479 "[%u, {\"state\": \"maximized\", \"focused\": false}]"; 480 function = new WindowsUpdateFunction(); 481 function->set_extension(extension.get()); 482 EXPECT_TRUE(MatchPattern( 483 utils::RunFunctionAndReturnError( 484 function.get(), 485 base::StringPrintf(kArgsMaximizedWithoutFocus, window_id), 486 browser()), 487 keys::kInvalidWindowStateError)); 488 489 static const char kArgsMinimizedWithBounds[] = 490 "[%u, {\"state\": \"minimized\", \"width\": 500}]"; 491 function = new WindowsUpdateFunction(); 492 function->set_extension(extension.get()); 493 EXPECT_TRUE(MatchPattern( 494 utils::RunFunctionAndReturnError( 495 function.get(), 496 base::StringPrintf(kArgsMinimizedWithBounds, window_id), 497 browser()), 498 keys::kInvalidWindowStateError)); 499 500 static const char kArgsMaximizedWithBounds[] = 501 "[%u, {\"state\": \"maximized\", \"width\": 500}]"; 502 function = new WindowsUpdateFunction(); 503 function->set_extension(extension.get()); 504 EXPECT_TRUE(MatchPattern( 505 utils::RunFunctionAndReturnError( 506 function.get(), 507 base::StringPrintf(kArgsMaximizedWithBounds, window_id), 508 browser()), 509 keys::kInvalidWindowStateError)); 510 } 511 512 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, DuplicateTab) { 513 content::OpenURLParams params(GURL(url::kAboutBlankURL), 514 content::Referrer(), 515 NEW_FOREGROUND_TAB, 516 content::PAGE_TRANSITION_LINK, 517 false); 518 content::WebContents* web_contents = browser()->OpenURL(params); 519 int tab_id = ExtensionTabUtil::GetTabId(web_contents); 520 int window_id = ExtensionTabUtil::GetWindowIdOfTab(web_contents); 521 int tab_index = -1; 522 TabStripModel* tab_strip; 523 ExtensionTabUtil::GetTabStripModel(web_contents, &tab_strip, &tab_index); 524 525 scoped_refptr<TabsDuplicateFunction> duplicate_tab_function( 526 new TabsDuplicateFunction()); 527 scoped_ptr<base::DictionaryValue> test_extension_value( 528 utils::ParseDictionary( 529 "{\"name\": \"Test\", \"version\": \"1.0\", \"permissions\": [\"tabs\"]}" 530 )); 531 scoped_refptr<Extension> empty_tab_extension( 532 utils::CreateExtension(test_extension_value.get())); 533 duplicate_tab_function->set_extension(empty_tab_extension.get()); 534 duplicate_tab_function->set_has_callback(true); 535 536 scoped_ptr<base::DictionaryValue> duplicate_result(utils::ToDictionary( 537 utils::RunFunctionAndReturnSingleResult( 538 duplicate_tab_function.get(), base::StringPrintf("[%u]", tab_id), 539 browser()))); 540 541 int duplicate_tab_id = utils::GetInteger(duplicate_result.get(), "id"); 542 int duplicate_tab_window_id = utils::GetInteger(duplicate_result.get(), 543 "windowId"); 544 int duplicate_tab_index = utils::GetInteger(duplicate_result.get(), "index"); 545 EXPECT_EQ(base::Value::TYPE_DICTIONARY, duplicate_result->GetType()); 546 // Duplicate tab id should be different from the original tab id. 547 EXPECT_NE(tab_id, duplicate_tab_id); 548 EXPECT_EQ(window_id, duplicate_tab_window_id); 549 EXPECT_EQ(tab_index + 1, duplicate_tab_index); 550 // The test empty tab extension has tabs permissions, therefore 551 // |duplicate_result| should contain url, title, and faviconUrl 552 // in the function result. 553 EXPECT_TRUE(utils::HasPrivacySensitiveFields(duplicate_result.get())); 554 } 555 556 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, DuplicateTabNoPermission) { 557 content::OpenURLParams params(GURL(url::kAboutBlankURL), 558 content::Referrer(), 559 NEW_FOREGROUND_TAB, 560 content::PAGE_TRANSITION_LINK, 561 false); 562 content::WebContents* web_contents = browser()->OpenURL(params); 563 int tab_id = ExtensionTabUtil::GetTabId(web_contents); 564 int window_id = ExtensionTabUtil::GetWindowIdOfTab(web_contents); 565 int tab_index = -1; 566 TabStripModel* tab_strip; 567 ExtensionTabUtil::GetTabStripModel(web_contents, &tab_strip, &tab_index); 568 569 scoped_refptr<TabsDuplicateFunction> duplicate_tab_function( 570 new TabsDuplicateFunction()); 571 scoped_refptr<Extension> empty_extension(utils::CreateEmptyExtension()); 572 duplicate_tab_function->set_extension(empty_extension.get()); 573 duplicate_tab_function->set_has_callback(true); 574 575 scoped_ptr<base::DictionaryValue> duplicate_result(utils::ToDictionary( 576 utils::RunFunctionAndReturnSingleResult( 577 duplicate_tab_function.get(), base::StringPrintf("[%u]", tab_id), 578 browser()))); 579 580 int duplicate_tab_id = utils::GetInteger(duplicate_result.get(), "id"); 581 int duplicate_tab_window_id = utils::GetInteger(duplicate_result.get(), 582 "windowId"); 583 int duplicate_tab_index = utils::GetInteger(duplicate_result.get(), "index"); 584 EXPECT_EQ(base::Value::TYPE_DICTIONARY, duplicate_result->GetType()); 585 // Duplicate tab id should be different from the original tab id. 586 EXPECT_NE(tab_id, duplicate_tab_id); 587 EXPECT_EQ(window_id, duplicate_tab_window_id); 588 EXPECT_EQ(tab_index + 1, duplicate_tab_index); 589 // The test empty extension has no permissions, therefore |duplicate_result| 590 // should not contain url, title, and faviconUrl in the function result. 591 EXPECT_FALSE(utils::HasPrivacySensitiveFields(duplicate_result.get())); 592 } 593 594 } // namespace extensions 595
