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

   1 // Copyright 2013 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_event_router.h"
   6
   7 #include "base/json/json_writer.h"
   8 #include "base/values.h"
   9 #include "chrome/browser/chrome_notification_types.h"
  10 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
  11 #include "chrome/browser/extensions/api/tabs/tabs_windows_api.h"
  12 #include "chrome/browser/extensions/api/tabs/windows_event_router.h"
  13 #include "chrome/browser/extensions/extension_tab_util.h"
  14 #include "chrome/browser/profiles/profile.h"
  15 #include "chrome/browser/ui/browser.h"
  16 #include "chrome/browser/ui/browser_iterator.h"
  17 #include "chrome/browser/ui/browser_list.h"
  18 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  19 #include "chrome/common/extensions/extension_constants.h"
  20 #include "content/public/browser/favicon_status.h"
  21 #include "content/public/browser/navigation_controller.h"
  22 #include "content/public/browser/navigation_entry.h"
  23 #include "content/public/browser/notification_service.h"
  24 #include "content/public/browser/notification_types.h"
  25 #include "content/public/browser/web_contents.h"
  26
  27 using base::DictionaryValue;
  28 using base::ListValue;
  29 using base::FundamentalValue;
  30 using content::NavigationController;
  31 using content::WebContents;
  32
  33 namespace extensions {
  34
  35 namespace {
  36
  37 namespace tabs = api::tabs;
  38
  39 void WillDispatchTabUpdatedEvent(
  40     WebContents* contents,
  41     const base::DictionaryValue* changed_properties,
  42     content::BrowserContext* context,
  43     const Extension* extension,
  44     base::ListValue* event_args) {
  45   // Overwrite the second argument with the appropriate properties dictionary,
  46   // depending on extension permissions.
  47   base::DictionaryValue* properties_value = changed_properties->DeepCopy();
  48   ExtensionTabUtil::ScrubTabValueForExtension(contents,
  49                                               extension,
  50                                               properties_value);
  51   event_args->Set(1, properties_value);
  52
  53   // Overwrite the third arg with our tab value as seen by this extension.
  54   event_args->Set(2, ExtensionTabUtil::CreateTabValue(contents, extension));
  55 }
  56
  57 }  // namespace
  58
  59 TabsEventRouter::TabEntry::TabEntry() : complete_waiting_on_load_(false),
  60                                         url_() {
  61 }
  62
  63 base::DictionaryValue* TabsEventRouter::TabEntry::UpdateLoadState(
  64     const WebContents* contents) {
  65   // The tab may go in & out of loading (for instance if iframes navigate).
  66   // We only want to respond to the first change from loading to !loading after
  67   // the NAV_ENTRY_COMMITTED was fired.
  68   if (!complete_waiting_on_load_ || contents->IsLoading())
  69     return NULL;
  70
  71   // Send "complete" state change.
  72   complete_waiting_on_load_ = false;
  73   base::DictionaryValue* changed_properties = new base::DictionaryValue();
  74   changed_properties->SetString(tabs_constants::kStatusKey,
  75                                 tabs_constants::kStatusValueComplete);
  76   return changed_properties;
  77 }
  78
  79 base::DictionaryValue* TabsEventRouter::TabEntry::DidNavigate(
  80     const WebContents* contents) {
  81   // Send "loading" state change.
  82   complete_waiting_on_load_ = true;
  83   base::DictionaryValue* changed_properties = new base::DictionaryValue();
  84   changed_properties->SetString(tabs_constants::kStatusKey,
  85                                 tabs_constants::kStatusValueLoading);
  86
  87   if (contents->GetURL() != url_) {
  88     url_ = contents->GetURL();
  89     changed_properties->SetString(tabs_constants::kUrlKey, url_.spec());
  90   }
  91
  92   return changed_properties;
  93 }
  94
  95 TabsEventRouter::TabsEventRouter(Profile* profile) : profile_(profile) {
  96   DCHECK(!profile->IsOffTheRecord());
  97
  98   BrowserList::AddObserver(this);
  99
 100   // Init() can happen after the browser is running, so catch up with any
 101   // windows that already exist.
 102   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
 103     RegisterForBrowserNotifications(*it);
 104
 105     // Also catch up our internal bookkeeping of tab entries.
 106     Browser* browser = *it;
 107     if (browser->tab_strip_model()) {
 108       for (int i = 0; i < browser->tab_strip_model()->count(); ++i) {
 109         WebContents* contents = browser->tab_strip_model()->GetWebContentsAt(i);
 110         int tab_id = ExtensionTabUtil::GetTabId(contents);
 111         tab_entries_[tab_id] = TabEntry();
 112       }
 113     }
 114   }
 115 }
 116
 117 TabsEventRouter::~TabsEventRouter() {
 118   BrowserList::RemoveObserver(this);
 119 }
 120
 121 void TabsEventRouter::OnBrowserAdded(Browser* browser) {
 122   RegisterForBrowserNotifications(browser);
 123 }
 124
 125 void TabsEventRouter::RegisterForBrowserNotifications(Browser* browser) {
 126   if (!profile_->IsSameProfile(browser->profile()))
 127     return;
 128   // Start listening to TabStripModel events for this browser.
 129   TabStripModel* tab_strip = browser->tab_strip_model();
 130   tab_strip->AddObserver(this);
 131
 132   for (int i = 0; i < tab_strip->count(); ++i) {
 133     RegisterForTabNotifications(tab_strip->GetWebContentsAt(i));
 134   }
 135 }
 136
 137 void TabsEventRouter::RegisterForTabNotifications(WebContents* contents) {
 138   registrar_.Add(
 139       this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
 140       content::Source<NavigationController>(&contents->GetController()));
 141
 142   // Observing NOTIFICATION_WEB_CONTENTS_DESTROYED is necessary because it's
 143   // possible for tabs to be created, detached and then destroyed without
 144   // ever having been re-attached and closed. This happens in the case of
 145   // a devtools WebContents that is opened in window, docked, then closed.
 146   registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
 147                  content::Source<WebContents>(contents));
 148
 149   registrar_.Add(this, chrome::NOTIFICATION_FAVICON_UPDATED,
 150                  content::Source<WebContents>(contents));
 151
 152   ZoomController::FromWebContents(contents)->AddObserver(this);
 153 }
 154
 155 void TabsEventRouter::UnregisterForTabNotifications(WebContents* contents) {
 156   registrar_.Remove(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
 157       content::Source<NavigationController>(&contents->GetController()));
 158   registrar_.Remove(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
 159       content::Source<WebContents>(contents));
 160   registrar_.Remove(this, chrome::NOTIFICATION_FAVICON_UPDATED,
 161       content::Source<WebContents>(contents));
 162
 163   ZoomController::FromWebContents(contents)->RemoveObserver(this);
 164 }
 165
 166 void TabsEventRouter::OnBrowserRemoved(Browser* browser) {
 167   if (!profile_->IsSameProfile(browser->profile()))
 168     return;
 169
 170   // Stop listening to TabStripModel events for this browser.
 171   browser->tab_strip_model()->RemoveObserver(this);
 172 }
 173
 174 void TabsEventRouter::OnBrowserSetLastActive(Browser* browser) {
 175   TabsWindowsAPI* tabs_window_api = TabsWindowsAPI::Get(profile_);
 176   if (tabs_window_api) {
 177     tabs_window_api->windows_event_router()->OnActiveWindowChanged(
 178         browser ? browser->extension_window_controller() : NULL);
 179   }
 180 }
 181
 182 static void WillDispatchTabCreatedEvent(WebContents* contents,
 183                                         bool active,
 184                                         content::BrowserContext* context,
 185                                         const Extension* extension,
 186                                         base::ListValue* event_args) {
 187   base::DictionaryValue* tab_value = ExtensionTabUtil::CreateTabValue(
 188       contents, extension);
 189   event_args->Clear();
 190   event_args->Append(tab_value);
 191   tab_value->SetBoolean(tabs_constants::kSelectedKey, active);
 192 }
 193
 194 void TabsEventRouter::TabCreatedAt(WebContents* contents,
 195                                    int index,
 196                                    bool active) {
 197   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
 198   scoped_ptr<base::ListValue> args(new base::ListValue);
 199   scoped_ptr<Event> event(new Event(tabs::OnCreated::kEventName, args.Pass()));
 200   event->restrict_to_browser_context = profile;
 201   event->user_gesture = EventRouter::USER_GESTURE_NOT_ENABLED;
 202   event->will_dispatch_callback =
 203       base::Bind(&WillDispatchTabCreatedEvent, contents, active);
 204   EventRouter::Get(profile)->BroadcastEvent(event.Pass());
 205
 206   RegisterForTabNotifications(contents);
 207 }
 208
 209 void TabsEventRouter::TabInsertedAt(WebContents* contents,
 210                                     int index,
 211                                     bool active) {
 212   // If tab is new, send created event.
 213   int tab_id = ExtensionTabUtil::GetTabId(contents);
 214   if (!GetTabEntry(contents)) {
 215     tab_entries_[tab_id] = TabEntry();
 216
 217     TabCreatedAt(contents, index, active);
 218     return;
 219   }
 220
 221   scoped_ptr<base::ListValue> args(new base::ListValue);
 222   args->Append(new FundamentalValue(tab_id));
 223
 224   base::DictionaryValue* object_args = new base::DictionaryValue();
 225   object_args->Set(tabs_constants::kNewWindowIdKey,
 226                    new FundamentalValue(
 227                        ExtensionTabUtil::GetWindowIdOfTab(contents)));
 228   object_args->Set(tabs_constants::kNewPositionKey,
 229                    new FundamentalValue(index));
 230   args->Append(object_args);
 231
 232   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
 233   DispatchEvent(profile, tabs::OnAttached::kEventName, args.Pass(),
 234                 EventRouter::USER_GESTURE_UNKNOWN);
 235 }
 236
 237 void TabsEventRouter::TabDetachedAt(WebContents* contents, int index) {
 238   if (!GetTabEntry(contents)) {
 239     // The tab was removed. Don't send detach event.
 240     return;
 241   }
 242
 243   scoped_ptr<base::ListValue> args(new base::ListValue);
 244   args->Append(
 245       new FundamentalValue(ExtensionTabUtil::GetTabId(contents)));
 246
 247   base::DictionaryValue* object_args = new base::DictionaryValue();
 248   object_args->Set(tabs_constants::kOldWindowIdKey,
 249                    new FundamentalValue(
 250                        ExtensionTabUtil::GetWindowIdOfTab(contents)));
 251   object_args->Set(tabs_constants::kOldPositionKey,
 252                    new FundamentalValue(index));
 253   args->Append(object_args);
 254
 255   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
 256   DispatchEvent(profile,
 257                 tabs::OnDetached::kEventName,
 258                 args.Pass(),
 259                 EventRouter::USER_GESTURE_UNKNOWN);
 260 }
 261
 262 void TabsEventRouter::TabClosingAt(TabStripModel* tab_strip_model,
 263                                    WebContents* contents,
 264                                    int index) {
 265   int tab_id = ExtensionTabUtil::GetTabId(contents);
 266
 267   scoped_ptr<base::ListValue> args(new base::ListValue);
 268   args->Append(new FundamentalValue(tab_id));
 269
 270   base::DictionaryValue* object_args = new base::DictionaryValue();
 271   object_args->SetInteger(tabs_constants::kWindowIdKey,
 272                           ExtensionTabUtil::GetWindowIdOfTab(contents));
 273   object_args->SetBoolean(tabs_constants::kWindowClosing,
 274                           tab_strip_model->closing_all());
 275   args->Append(object_args);
 276
 277   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
 278   DispatchEvent(profile,
 279                 tabs::OnRemoved::kEventName,
 280                 args.Pass(),
 281                 EventRouter::USER_GESTURE_UNKNOWN);
 282
 283   int removed_count = tab_entries_.erase(tab_id);
 284   DCHECK_GT(removed_count, 0);
 285
 286   UnregisterForTabNotifications(contents);
 287 }
 288
 289 void TabsEventRouter::ActiveTabChanged(WebContents* old_contents,
 290                                        WebContents* new_contents,
 291                                        int index,
 292                                        int reason) {
 293   scoped_ptr<base::ListValue> args(new base::ListValue);
 294   int tab_id = ExtensionTabUtil::GetTabId(new_contents);
 295   args->Append(new FundamentalValue(tab_id));
 296
 297   base::DictionaryValue* object_args = new base::DictionaryValue();
 298   object_args->Set(tabs_constants::kWindowIdKey,
 299                    new FundamentalValue(
 300                        ExtensionTabUtil::GetWindowIdOfTab(new_contents)));
 301   args->Append(object_args);
 302
 303   // The onActivated event replaced onActiveChanged and onSelectionChanged. The
 304   // deprecated events take two arguments: tabId, {windowId}.
 305   Profile* profile =
 306       Profile::FromBrowserContext(new_contents->GetBrowserContext());
 307   EventRouter::UserGestureState gesture =
 308       reason & CHANGE_REASON_USER_GESTURE
 309       ? EventRouter::USER_GESTURE_ENABLED
 310       : EventRouter::USER_GESTURE_NOT_ENABLED;
 311   DispatchEvent(profile,
 312                 tabs::OnSelectionChanged::kEventName,
 313                 scoped_ptr<base::ListValue>(args->DeepCopy()),
 314                 gesture);
 315   DispatchEvent(profile,
 316                 tabs::OnActiveChanged::kEventName,
 317                 scoped_ptr<base::ListValue>(args->DeepCopy()),
 318                 gesture);
 319
 320   // The onActivated event takes one argument: {windowId, tabId}.
 321   args->Remove(0, NULL);
 322   object_args->Set(tabs_constants::kTabIdKey,
 323                    new FundamentalValue(tab_id));
 324   DispatchEvent(profile, tabs::OnActivated::kEventName, args.Pass(), gesture);
 325 }
 326
 327 void TabsEventRouter::TabSelectionChanged(
 328     TabStripModel* tab_strip_model,
 329     const ui::ListSelectionModel& old_model) {
 330   ui::ListSelectionModel::SelectedIndices new_selection =
 331       tab_strip_model->selection_model().selected_indices();
 332   scoped_ptr<base::ListValue> all_tabs(new base::ListValue);
 333
 334   for (size_t i = 0; i < new_selection.size(); ++i) {
 335     int index = new_selection[i];
 336     WebContents* contents = tab_strip_model->GetWebContentsAt(index);
 337     if (!contents)
 338       break;
 339     int tab_id = ExtensionTabUtil::GetTabId(contents);
 340     all_tabs->Append(new FundamentalValue(tab_id));
 341   }
 342
 343   scoped_ptr<base::ListValue> args(new base::ListValue);
 344   scoped_ptr<base::DictionaryValue> select_info(new base::DictionaryValue);
 345
 346   select_info->Set(
 347       tabs_constants::kWindowIdKey,
 348       new FundamentalValue(
 349           ExtensionTabUtil::GetWindowIdOfTabStripModel(tab_strip_model)));
 350
 351   select_info->Set(tabs_constants::kTabIdsKey, all_tabs.release());
 352   args->Append(select_info.release());
 353
 354   // The onHighlighted event replaced onHighlightChanged.
 355   Profile* profile = tab_strip_model->profile();
 356   DispatchEvent(profile,
 357                 tabs::OnHighlightChanged::kEventName,
 358                 scoped_ptr<base::ListValue>(args->DeepCopy()),
 359                 EventRouter::USER_GESTURE_UNKNOWN);
 360   DispatchEvent(profile,
 361                 tabs::OnHighlighted::kEventName,
 362                 args.Pass(),
 363                 EventRouter::USER_GESTURE_UNKNOWN);
 364 }
 365
 366 void TabsEventRouter::TabMoved(WebContents* contents,
 367                                int from_index,
 368                                int to_index) {
 369   scoped_ptr<base::ListValue> args(new base::ListValue);
 370   args->Append(
 371       new FundamentalValue(ExtensionTabUtil::GetTabId(contents)));
 372
 373   base::DictionaryValue* object_args = new base::DictionaryValue();
 374   object_args->Set(tabs_constants::kWindowIdKey,
 375                    new FundamentalValue(
 376                        ExtensionTabUtil::GetWindowIdOfTab(contents)));
 377   object_args->Set(tabs_constants::kFromIndexKey,
 378                    new FundamentalValue(from_index));
 379   object_args->Set(tabs_constants::kToIndexKey,
 380                    new FundamentalValue(to_index));
 381   args->Append(object_args);
 382
 383   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
 384   DispatchEvent(profile,
 385                 tabs::OnMoved::kEventName,
 386                 args.Pass(),
 387                 EventRouter::USER_GESTURE_UNKNOWN);
 388 }
 389
 390 void TabsEventRouter::TabUpdated(WebContents* contents, bool did_navigate) {
 391   TabEntry* entry = GetTabEntry(contents);
 392   scoped_ptr<base::DictionaryValue> changed_properties;
 393
 394   CHECK(entry);
 395
 396   if (did_navigate)
 397     changed_properties.reset(entry->DidNavigate(contents));
 398   else
 399     changed_properties.reset(entry->UpdateLoadState(contents));
 400
 401   if (changed_properties)
 402     DispatchTabUpdatedEvent(contents, changed_properties.Pass());
 403 }
 404
 405 void TabsEventRouter::FaviconUrlUpdated(WebContents* contents) {
 406     content::NavigationEntry* entry =
 407         contents->GetController().GetVisibleEntry();
 408     if (!entry || !entry->GetFavicon().valid)
 409       return;
 410     scoped_ptr<base::DictionaryValue> changed_properties(
 411         new base::DictionaryValue);
 412     changed_properties->SetString(
 413         tabs_constants::kFaviconUrlKey,
 414         entry->GetFavicon().url.possibly_invalid_spec());
 415     DispatchTabUpdatedEvent(contents, changed_properties.Pass());
 416 }
 417
 418 void TabsEventRouter::DispatchEvent(
 419     Profile* profile,
 420     const std::string& event_name,
 421     scoped_ptr<base::ListValue> args,
 422     EventRouter::UserGestureState user_gesture) {
 423   EventRouter* event_router = EventRouter::Get(profile);
 424   if (!profile_->IsSameProfile(profile) || !event_router)
 425     return;
 426
 427   scoped_ptr<Event> event(new Event(event_name, args.Pass()));
 428   event->restrict_to_browser_context = profile;
 429   event->user_gesture = user_gesture;
 430   event_router->BroadcastEvent(event.Pass());
 431 }
 432
 433 void TabsEventRouter::DispatchSimpleBrowserEvent(
 434     Profile* profile, const int window_id, const std::string& event_name) {
 435   if (!profile_->IsSameProfile(profile))
 436     return;
 437
 438   scoped_ptr<base::ListValue> args(new base::ListValue);
 439   args->Append(new FundamentalValue(window_id));
 440
 441   DispatchEvent(profile,
 442                 event_name,
 443                 args.Pass(),
 444                 EventRouter::USER_GESTURE_UNKNOWN);
 445 }
 446
 447 void TabsEventRouter::DispatchTabUpdatedEvent(
 448     WebContents* contents,
 449     scoped_ptr<base::DictionaryValue> changed_properties) {
 450   DCHECK(changed_properties);
 451   DCHECK(contents);
 452
 453   // The state of the tab (as seen from the extension point of view) has
 454   // changed.  Send a notification to the extension.
 455   scoped_ptr<base::ListValue> args_base(new base::ListValue);
 456
 457   // First arg: The id of the tab that changed.
 458   args_base->AppendInteger(ExtensionTabUtil::GetTabId(contents));
 459
 460   // Second arg: An object containing the changes to the tab state.  Filled in
 461   // by WillDispatchTabUpdatedEvent as a copy of changed_properties, if the
 462   // extension has the tabs permission.
 463
 464   // Third arg: An object containing the state of the tab. Filled in by
 465   // WillDispatchTabUpdatedEvent.
 466   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
 467
 468   scoped_ptr<Event> event(
 469       new Event(tabs::OnUpdated::kEventName, args_base.Pass()));
 470   event->restrict_to_browser_context = profile;
 471   event->user_gesture = EventRouter::USER_GESTURE_NOT_ENABLED;
 472   event->will_dispatch_callback =
 473       base::Bind(&WillDispatchTabUpdatedEvent,
 474                  contents,
 475                  changed_properties.get());
 476   EventRouter::Get(profile)->BroadcastEvent(event.Pass());
 477 }
 478
 479 TabsEventRouter::TabEntry* TabsEventRouter::GetTabEntry(WebContents* contents) {
 480   int tab_id = ExtensionTabUtil::GetTabId(contents);
 481   std::map<int, TabEntry>::iterator i = tab_entries_.find(tab_id);
 482   if (tab_entries_.end() == i)
 483     return NULL;
 484   return &i->second;
 485 }
 486
 487 void TabsEventRouter::Observe(int type,
 488                               const content::NotificationSource& source,
 489                               const content::NotificationDetails& details) {
 490   if (type == content::NOTIFICATION_NAV_ENTRY_COMMITTED) {
 491     NavigationController* source_controller =
 492         content::Source<NavigationController>(source).ptr();
 493     TabUpdated(source_controller->GetWebContents(), true);
 494   } else if (type == content::NOTIFICATION_WEB_CONTENTS_DESTROYED) {
 495     // Tab was destroyed after being detached (without being re-attached).
 496     WebContents* contents = content::Source<WebContents>(source).ptr();
 497     registrar_.Remove(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
 498         content::Source<NavigationController>(&contents->GetController()));
 499     registrar_.Remove(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
 500         content::Source<WebContents>(contents));
 501     registrar_.Remove(this, chrome::NOTIFICATION_FAVICON_UPDATED,
 502         content::Source<WebContents>(contents));
 503   } else if (type == chrome::NOTIFICATION_FAVICON_UPDATED) {
 504     bool icon_url_changed = *content::Details<bool>(details).ptr();
 505     if (icon_url_changed)
 506       FaviconUrlUpdated(content::Source<WebContents>(source).ptr());
 507   } else {
 508     NOTREACHED();
 509   }
 510 }
 511
 512 void TabsEventRouter::TabChangedAt(WebContents* contents,
 513                                    int index,
 514                                    TabChangeType change_type) {
 515   TabUpdated(contents, false);
 516 }
 517
 518 void TabsEventRouter::TabReplacedAt(TabStripModel* tab_strip_model,
 519                                     WebContents* old_contents,
 520                                     WebContents* new_contents,
 521                                     int index) {
 522   // Notify listeners that the next tabs closing or being added are due to
 523   // WebContents being swapped.
 524   const int new_tab_id = ExtensionTabUtil::GetTabId(new_contents);
 525   const int old_tab_id = ExtensionTabUtil::GetTabId(old_contents);
 526   scoped_ptr<base::ListValue> args(new base::ListValue);
 527   args->Append(new FundamentalValue(new_tab_id));
 528   args->Append(new FundamentalValue(old_tab_id));
 529
 530   DispatchEvent(Profile::FromBrowserContext(new_contents->GetBrowserContext()),
 531                 tabs::OnReplaced::kEventName,
 532                 args.Pass(),
 533                 EventRouter::USER_GESTURE_UNKNOWN);
 534
 535   // Update tab_entries_.
 536   const int removed_count = tab_entries_.erase(old_tab_id);
 537   DCHECK_GT(removed_count, 0);
 538   UnregisterForTabNotifications(old_contents);
 539
 540   if (!GetTabEntry(new_contents)) {
 541     tab_entries_[new_tab_id] = TabEntry();
 542     RegisterForTabNotifications(new_contents);
 543   }
 544 }
 545
 546 void TabsEventRouter::TabPinnedStateChanged(WebContents* contents, int index) {
 547   TabStripModel* tab_strip = NULL;
 548   int tab_index;
 549
 550   if (ExtensionTabUtil::GetTabStripModel(contents, &tab_strip, &tab_index)) {
 551     scoped_ptr<base::DictionaryValue> changed_properties(
 552         new base::DictionaryValue());
 553     changed_properties->SetBoolean(tabs_constants::kPinnedKey,
 554                                    tab_strip->IsTabPinned(tab_index));
 555     DispatchTabUpdatedEvent(contents, changed_properties.Pass());
 556   }
 557 }
 558
 559 void TabsEventRouter::OnZoomChanged(
 560     const ZoomController::ZoomChangedEventData& data) {
 561   DCHECK(data.web_contents);
 562   int tab_id = ExtensionTabUtil::GetTabId(data.web_contents);
 563   if (tab_id < 0)
 564     return;
 565
 566   // Prepare the zoom change information.
 567   api::tabs::OnZoomChange::ZoomChangeInfo zoom_change_info;
 568   zoom_change_info.tab_id = tab_id;
 569   zoom_change_info.old_zoom_factor =
 570       content::ZoomLevelToZoomFactor(data.old_zoom_level);
 571   zoom_change_info.new_zoom_factor =
 572       content::ZoomLevelToZoomFactor(data.new_zoom_level);
 573   ZoomModeToZoomSettings(data.zoom_mode,
 574                          &zoom_change_info.zoom_settings);
 575
 576   // Dispatch the |onZoomChange| event.
 577   Profile* profile = Profile::FromBrowserContext(
 578       data.web_contents->GetBrowserContext());
 579   DispatchEvent(profile,
 580                 tabs::OnZoomChange::kEventName,
 581                 api::tabs::OnZoomChange::Create(zoom_change_info),
 582                 EventRouter::USER_GESTURE_UNKNOWN);
 583 }
 584
 585 }  // namespace extensions