Make an inserted selected tab selected before calling TabInsertedAt on observers.

chrome/browser/extensions/extension_tabs_module.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/extensions/extension_tabs_module.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 60 matching lines @@
 
   if (error_message)
     *error_message = ExtensionErrorUtils::FormatErrorMessage(
         keys::kWindowNotFoundError, base::IntToString(window_id));
 
   return NULL;
 }
 
 // |error_message| can optionally be passed in and will be set with an
 // appropriate message if the tab cannot be found by id.
-bool GetTabById(int tab_id, Profile* profile,
+bool GetTabById(int tab_id,
+                Profile* profile,
                 bool include_incognito,
                 Browser** browser,
                 TabStripModel** tab_strip,
                 TabContentsWrapper** contents,
                 int* tab_index,
                 std::string* error_message) {
   if (ExtensionTabUtil::GetTabById(tab_id, profile, include_incognito,
                                    browser, tab_strip, contents, tab_index))
     return true;
 
@@ skipping 65 matching lines @@
   ListValue* tab_list = new ListValue();
   TabStripModel* tab_strip = browser->tabstrip_model();
   for (int i = 0; i < tab_strip->count(); ++i) {
     tab_list->Append(ExtensionTabUtil::CreateTabValue(
         tab_strip->GetTabContentsAt(i)->tab_contents(), tab_strip, i));
   }
 
   return tab_list;
 }
 
-DictionaryValue* ExtensionTabUtil::CreateTabValue(
-    const TabContents* contents, TabStripModel* tab_strip, int tab_index) {
+DictionaryValue* ExtensionTabUtil::CreateTabValue(const TabContents* contents,
+                                                  TabStripModel* tab_strip,
+                                                  int tab_index) {
   DictionaryValue* result = new DictionaryValue();
   result->SetInteger(keys::kIdKey, ExtensionTabUtil::GetTabId(contents));
   result->SetInteger(keys::kIndexKey, tab_index);
   result->SetInteger(keys::kWindowIdKey,
                      ExtensionTabUtil::GetWindowIdOfTab(contents));
   result->SetString(keys::kUrlKey, contents->GetURL().spec());
   result->SetString(keys::kStatusKey, GetTabStatusText(contents->is_loading()));
   result->SetBoolean(keys::kSelectedKey,
                      tab_strip && tab_index == tab_strip->active_index());
   result->SetBoolean(keys::kPinnedKey,
                      tab_strip && tab_strip->IsTabPinned(tab_index));
   result->SetString(keys::kTitleKey, contents->GetTitle());
   result->SetBoolean(keys::kIncognitoKey,
                      contents->profile()->IsOffTheRecord());
 
   if (!contents->is_loading()) {
     NavigationEntry* entry = contents->controller().GetActiveEntry();
     if (entry) {
       if (entry->favicon().is_valid())
         result->SetString(keys::kFaviconUrlKey, entry->favicon().url().spec());
     }
   }
 
   return result;
 }
 
+DictionaryValue* ExtensionTabUtil::CreateTabValueActive(
+    const TabContents* contents,
+    bool active) {
+  DictionaryValue* result = ExtensionTabUtil::CreateTabValue(contents);
+  result->SetBoolean(keys::kSelectedKey, active);
+  return result;
+}
+
 // if |populate| is true, each window gets a list property |tabs| which contains
 // fully populated tab objects.
 DictionaryValue* ExtensionTabUtil::CreateWindowValue(const Browser* browser,
                                                      bool populate_tabs) {
   DCHECK(browser);
   DCHECK(browser->window());
   DictionaryValue* result = new DictionaryValue();
   result->SetInteger(keys::kIdKey, ExtensionTabUtil::GetWindowId(browser));
   result->SetBoolean(keys::kIncognitoKey,
                      browser->profile()->IsOffTheRecord());
@@ skipping 48 matching lines @@
   *contents = browser->GetSelectedTabContentsWrapper();
   if (*contents) {
     if (tab_id)
       *tab_id = ExtensionTabUtil::GetTabId((*contents)->tab_contents());
     return true;
   }
 
   return false;
 }
 
-bool ExtensionTabUtil::GetTabById(int tab_id, Profile* profile,
+bool ExtensionTabUtil::GetTabById(int tab_id,
+                                  Profile* profile,
                                   bool include_incognito,
                                   Browser** browser,
                                   TabStripModel** tab_strip,
                                   TabContentsWrapper** contents,
                                   int* tab_index) {
   Profile* incognito_profile =
       include_incognito && profile->HasOffTheRecordProfile() ?
           profile->GetOffTheRecordProfile() : NULL;
   for (BrowserList::const_iterator iter = BrowserList::begin();
        iter != BrowserList::end(); ++iter) {
@@ skipping 339 matching lines @@
   if (update_props->HasKey(keys::kHeightKey)) {
     EXTENSION_FUNCTION_VALIDATE(update_props->GetInteger(
         keys::kHeightKey,
         &bounds_val));
     bounds.set_height(bounds_val);
     set_bounds = true;
   }
   if (set_bounds)
     browser->window()->SetBounds(bounds);
 
-  bool selected_val = false;
+  bool active_val = false;
   if (update_props->HasKey(keys::kFocusedKey)) {
     EXTENSION_FUNCTION_VALIDATE(update_props->GetBoolean(
-        keys::kFocusedKey, &selected_val));
-    if (selected_val)
+        keys::kFocusedKey, &active_val));
+    if (active_val)
       browser->window()->Activate();
     else
       browser->window()->Deactivate();
   }
 
   result_.reset(ExtensionTabUtil::CreateWindowValue(browser, false));
 
   return true;
 }
 
@@ skipping 705 matching lines @@
   // called for every API call the extension made.
   GotLanguage(language);
 }
 
 void DetectTabLanguageFunction::GotLanguage(const std::string& language) {
   result_.reset(Value::CreateStringValue(language.c_str()));
   SendResponse(true);
 
   Release();  // Balanced in Run()
 }