Chrome Extensions chrome.experimental.offscreenTabs.* API implementation, docs, and test.

chrome/browser/extensions/extension_offscreen_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_offscreen_tabs_module.h"
+
+#include <algorithm>
+#include <hash_map>
+#include <vector>
+
+#include "base/base64.h"
+#include "base/json/json_writer.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/stl_util.h"
+#include "base/string_number_conversions.h"
+#include "base/string_util.h"
+#include "base/values.h"
+#include "chrome/browser/extensions/extension_event_router.h"
+#include "chrome/browser/extensions/extension_function_dispatcher.h"
+#include "chrome/browser/extensions/extension_host.h"
+#include "chrome/browser/extensions/extension_message_service.h"
+#include "chrome/browser/extensions/extension_offscreen_tabs_module_constants.h"
+#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/extension_tabs_module.h"
+#include "chrome/browser/net/url_fixer_upper.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/browser_navigator.h"
+#include "chrome/browser/ui/browser_window.h"
+#include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/ui/window_sizer.h"
+#include "chrome/common/chrome_notification_types.h"
+#include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/extension_error_utils.h"
+#include "chrome/common/extensions/extension_messages.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/common/url_constants.h"
+#include "content/browser/renderer_host/backing_store.h"
+#include "content/browser/renderer_host/render_view_host.h"
+#include "content/browser/renderer_host/render_view_host_delegate.h"
+#include "content/browser/tab_contents/navigation_entry.h"
+#include "content/browser/tab_contents/tab_contents.h"
+#include "content/browser/tab_contents/tab_contents_view.h"
+#include "content/common/content_client.h"
+#include "content/common/notification_service.h"
+#include "skia/ext/image_operations.h"
+#include "skia/ext/platform_canvas.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/codec/jpeg_codec.h"
+#include "ui/gfx/codec/png_codec.h"
+
+using WebKit::WebInputEvent;
+
+namespace keys = extension_offscreen_tabs_module_constants;
+
+namespace {
+
+// Offscreen Tab ---------------------------------------------------------------
+
+// This class is responsible for the creation and destruction of offscreen tabs,
+// as well as dispatching an onUpdated event.
+class OffscreenTab : public NotificationObserver {
+ public:
+  OffscreenTab();
+  ~OffscreenTab();
+  void Init(const GURL& url, const int width, const int height,

[sky, 2011/09/13 23:42:23]

when you wrap, each param goes on its own line.

[alexbost, 2011/09/14 21:45:30]

Done.

+            const Extension* extension, Profile* profile,
+            ExtensionFunctionDispatcher* dispatcher);
+
+  TabContents* GetContents();
+  DictionaryValue* CreateValue();

[sky, 2011/09/13 23:42:23]

Description? And document return value.

[alexbost, 2011/09/14 21:45:30]

Done.

+
+  void SetUrl(const GURL& url);
+  void SetSize(int width, int height);
+
+ private:
+  void RegisterForTabNotifications();
+  void UnregisterForTabNotifications();
+  virtual void Observe(const int type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details) OVERRIDE;
+  NotificationRegistrar registrar_;

[sky, 2011/09/13 23:42:23]

newline between 81 and 82

[alexbost, 2011/09/14 21:45:30]

Done.

+
+  TabContents* contents_;

[sky, 2011/09/13 23:42:23]

Document ownership.

[alexbost, 2011/09/14 21:45:30]

Done.

+
+  DISALLOW_COPY_AND_ASSIGN(OffscreenTab);
+};
+
+// Tab -------------------------------------------------------------------------
+
+// This class holds info about a tab that has spawned at least one offscreen tab
+// We will call such tab the 'parent' of the offscreen tabs it has spawned.
+// Each Tab keeps track of its child offscreen tabs. The Tab is also responsible
+// for killing its children when it navigates away or gets closed.
+class Tab : public NotificationObserver {
+ public:
+  Tab();
+  ~Tab();
+  void Init(TabContents* tab_contents, const std::string* extension_id);
+
+  TabContents* GetContents();
+  const std::vector<OffscreenTab*> GetOffscreenTabs();

[sky, 2011/09/13 23:42:23]

this should return a reference.

[alexbost, 2011/09/14 21:45:30]

Done.

+  const std::string* GetExtensionId();
+
+  void AddOffscreenTab(OffscreenTab *tab);
+  void RemoveOffscreenTab(OffscreenTab *tab);
+
+ private:
+  void RegisterForTabNotifications();
+  void UnregisterForTabNotifications();
+  virtual void Observe(const int type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details) OVERRIDE;
+  NotificationRegistrar registrar_;
+
+  TabContents* contents_;

[sky, 2011/09/13 23:42:23]

Document ownerhsip.

[alexbost, 2011/09/14 21:45:30]

Done.

+  std::vector<OffscreenTab*> offscreen_tabs_;
+  const std::string* extension_id_;

[sky, 2011/09/13 23:42:23]

Does this really need to store a raw pointer? A value is much safer.

[alexbost, 2011/09/14 21:45:30]

Done.

+
+  DISALLOW_COPY_AND_ASSIGN(Tab);
+};
+
+// Map -------------------------------------------------------------------------
+
+// This map keeps track of all tabs that are happy parents of offscreen tabs.
+class Map {
+ public:
+  Map();
+  ~Map();
+
+  bool GetOffscreenTab(const int tab_id,
+                       ExtensionFunctionDispatcher* dispatcher,

[sky, 2011/09/13 23:42:23]

each param on its own line, here and other functions in this class.

[alexbost, 2011/09/14 21:45:30]

Done.

+                       Profile* profile, OffscreenTab** offscreen_tab,
+                       std::string* error_message);
+  bool GetTab(const int tab_id, Tab** tab, std::string* error_message);
+  bool GetTabOfOffscreenTab(TabContents* offscreen_tab_contents, Tab** tab,
+                            std::string* error_message);
+  bool AddOffscreenTab(OffscreenTab* offscreen_tab,
+                       ExtensionFunctionDispatcher* dispatcher,
+                       Profile* profile, const std::string* ext_id,
+                       std::string* error_message);
+  bool RemoveOffscreenTab(const int tab_id,
+                          ExtensionFunctionDispatcher* dispatcher,
+                          Profile* profile, std::string* error_message);
+  bool RemoveTab(const int tab_id, std::string* error_message);
+
+ private:
+  typedef base::hash_map<int, Tab*> TabMap;
+  TabMap map;
+
+  DISALLOW_COPY_AND_ASSIGN(Map);
+};
+
+typedef std::vector<OffscreenTab*> TabVector;
+typedef TabVector::iterator TabIterator;
+
+// Variables -------------------------------------------------------------------
+
+Map* map = NULL;
+
+// Background page tab contents. Used by the test API.
+TabContents* background_page_tab_contents = NULL;
+
+// Util ------------------------------------------------------------------------
+
+Map* GetMap() {

[sky, 2011/09/13 23:42:23]

Add descriptions on all your functions.

[alexbost, 2011/09/14 21:45:30]

Done.

+  if (map == NULL)
+    map = new Map();
+
+  return map;
+}
+
+TabContents* GetBackgroundPageTabContents(Profile* profile) {
+  if (profile && background_page_tab_contents == NULL)

[sky, 2011/09/13 23:42:23]

What happens in a multi-profile world? Don't you need a background tab contents
per profile?

[alexbost, 2011/09/14 21:45:30]

This method is intended only for testing purposes. We are assuming that
offscreen tabs will not be created by background pages with the exception of the
API test background page. I will add a TODO for the multi-profile case.

[sky, 2011/09/14 23:34:44]

It looks like GetCurrentTab and OffscreenTab::Observe call into this, and they
don't look testing specific. Or maybe I'm missing something?

[alexbost, 2011/09/15 03:29:49]

The API tests (chrome/test/data/extensions/api_test/offscreen_tabs/test.html)
call all API methods so GetCurrentTab and OffscreenTab::Observe get called
during the tests.

[sky, 2011/09/15 20:05:57]

Aren't GetCurrentTab and OffscreenTab::Observe used by non-testing code paths
too though?

[alexbost, 2011/09/15 20:57:57]

They are. I am not sure what you are suggesting though.

[sky, 2011/09/15 21:39:17]

GetBackgroundTabContents creates and returns a TabContents all the time with a
specific profile. You said the TabContents is only used for testing, yet it
seems as though it's created all the time and leaked. If it's only used for
testing it should be made sure that it's only created then.

[alexbost, 2011/09/15 23:01:29]

GetBackgroundTabContents is (now) only called from GetCurrentTab when there are
no associated TabContents, which should make things more obvious. About leaking,
notice that the API test removes all offscreen tabs at the end which causes the
fake TabContents for the background page to be deleted too.

+    background_page_tab_contents =
+        new TabContents(profile, NULL, MSG_ROUTING_NONE, NULL, NULL);
+
+  return background_page_tab_contents;
+}
+
+bool GetCurrentTab(TabContents** tab_contents,
+                   ExtensionFunctionDispatcher* dispatcher,
+                   Profile* profile,
+                   std::string* error_message) {
+  *tab_contents = dispatcher->delegate()->GetAssociatedTabContents();
+
+  // Background page (no associated tab contents).
+  if (!*tab_contents)
+    *tab_contents = GetBackgroundPageTabContents(profile);
+
+  if (tab_contents)

[sky, 2011/09/13 23:42:23]

*tab_contents ?

[alexbost, 2011/09/14 21:45:30]

Done.

+    return true;
+
+  *error_message = keys::kCurrentTabNotFound;
+  return false;
+}
+
+// TODO(alexbost): Needs refactoring. Similar method in extension_tabs_module.
+// Takes |url_string| and returns a GURL which is either valid and absolute
+// or invalid. If |url_string| is not directly interpretable as a valid (it is
+// likely a relative URL) an attempt is made to resolve it. |extension| is
+// provided so it can be resolved relative to its extension base
+// (chrome-extension://<id>/). Using the source frame url would be more correct,
+// but because the api shipped with urls resolved relative to their extension
+// base, we decided it wasn't worth breaking existing extensions to fix.
+GURL ResolvePossiblyRelativeURL(const std::string& url_string,
+                                const Extension* extension) {
+  GURL url = GURL(url_string);
+  if (!url.is_valid())
+    url = extension->GetResourceURL(url_string);

[sky, 2011/09/13 23:42:23]

This seems like it may have security implications I don't quite know. You should
talk with the extensions guy (Aaron, or Antony..) to make sure it's ok.

[alexbost, 2011/09/14 21:45:30]

I copied this function verbatim from the tabs API.

[sky, 2011/09/14 23:34:44]

Expose a method that both places can use rather copying.

[alexbost, 2011/09/15 03:29:49]

At the extension API review meeting we decided that additional meetings are
needed for long term redesign of the way extensions and tabs work and how that
would integrate offscreen tabs. In the short term, however, we decided to move
forward with checking the Offscreen Tabs API into experimental as it is. All
methods that need refactoring are marked with TODOs, and we decided.

+
+  return url;
+}
+
+// TODO(alexbost): Needs refactoring. Similar method in extension_tabs_module.
+bool IsCrashURL(const GURL& url) {
+  // Check a fixed-up URL, to normalize the scheme and parse hosts correctly.
+  GURL fixed_url =
+      URLFixerUpper::FixupURL(url.possibly_invalid_spec(), std::string());

[sky, 2011/09/13 23:42:23]

Why do we need to fix this up?

[alexbost, 2011/09/14 21:45:30]

I copied this function verbatim from the tabs API.

[sky, 2011/09/14 23:34:44]

Expose a method that both places can use rather copying.

[alexbost, 2011/09/15 03:29:49]

See above.

+  return (fixed_url.SchemeIs(chrome::kChromeUIScheme) &&
+          (fixed_url.host() == chrome::kChromeUIBrowserCrashHost ||
+           fixed_url.host() == chrome::kChromeUICrashHost));
+}
+
+int GetTabWidth(const TabContents* tab_contents) {

[sky, 2011/09/13 23:42:23]

This should take a TabCONtentsWrapper, not a tab_contents. Also, how about a
single method: GetTabSize that returns a gfx::Size.

[alexbost, 2011/09/14 21:45:30]

Done.

+  const TabContentsWrapper* tab =
+      TabContentsWrapper::GetCurrentWrapperForContents(tab_contents);
+
+  if (tab && tab->view())
+    return tab->view()->GetContainerSize().width();
+
+  return -1;
+}
+
+int GetTabHeight(const TabContents* tab_contents) {
+  const TabContentsWrapper* tab =
+      TabContentsWrapper::GetCurrentWrapperForContents(tab_contents);
+
+  if (tab && tab->view())
+    return tab->view()->GetContainerSize().height();
+
+  return -1;
+}
+
+// Offscreen Tab ---------------------------------------------------------------
+
+OffscreenTab::OffscreenTab() {}

[sky, 2011/09/13 23:42:23]

initialize contents_. Although once you convert to scoped_ptr you won't need it.

[alexbost, 2011/09/14 21:45:30]

Done.

+
+OffscreenTab::~OffscreenTab() {
+  if (contents_) {
+    UnregisterForTabNotifications();

[sky, 2011/09/13 23:42:23]

This is done by virtue of the registrar_ being destroyed. You shouldn't have to
explicitly do it. In fact, you should probably move register into into and nuke
both register/unregister.

[alexbost, 2011/09/14 21:45:30]

Done.

+
+    // TODO(alexbost): Is this the best way to close an offscreen tab?
+    delete TabContentsWrapper::GetCurrentWrapperForContents(contents_);
+  }
+}
+
+void OffscreenTab::Init(const GURL& url, const int width, const int height,
+                        const Extension* extension, Profile* profile,
+                        ExtensionFunctionDispatcher* dispatcher) {
+  // Create the offscreen tab.
+  contents_ = new TabContents(profile, NULL, MSG_ROUTING_NONE, NULL, NULL);

[sky, 2011/09/13 23:42:23]

contents_ should be a scoped_ptr<TabContentsWrapper>

[alexbost, 2011/09/14 21:45:30]

Done.

+  new TabContentsWrapper(contents_);
+
+  SetSize(width, height);  // Setting the size starts the renderer.
+  SetUrl(url);
+
+  RegisterForTabNotifications();
+}
+
+TabContents* OffscreenTab::GetContents() {
+  return contents_;
+}
+
+DictionaryValue* OffscreenTab::CreateValue() {
+  DictionaryValue* result = new DictionaryValue();
+
+  result->SetInteger(keys::kIdKey, ExtensionTabUtil::GetTabId(contents_));
+  result->SetString(keys::kUrlKey, contents_->GetURL().spec());
+  result->SetInteger(keys::kWidthKey, GetTabWidth(contents_));
+  result->SetInteger(keys::kHeightKey, GetTabHeight(contents_));
+
+  return result;
+}
+
+void OffscreenTab::SetUrl(const GURL& url) {
+  contents_->controller().LoadURL(url, GURL(), PageTransition::LINK);
+}
+void OffscreenTab::SetSize(int width, int height) {

[sky, 2011/09/13 23:42:23]

newline between 288 and 289

[alexbost, 2011/09/14 21:45:30]

Done.

+  contents_->view()->SizeContents(gfx::Size(width, height));
+}
+
+void OffscreenTab::RegisterForTabNotifications() {
+  registrar_.Add(this,
+                 content::NOTIFICATION_NAV_ENTRY_COMMITTED,
+                 Source<NavigationController>(&contents_->controller()));
+}
+
+void OffscreenTab::UnregisterForTabNotifications() {
+  registrar_.Remove(this,
+                    content::NOTIFICATION_NAV_ENTRY_COMMITTED,
+                    Source<NavigationController>(&contents_->controller()));
+}
+
+void OffscreenTab::Observe(const int type,
+                           const NotificationSource& source,
+                           const NotificationDetails& details) {
+  DCHECK(type == content::NOTIFICATION_NAV_ENTRY_COMMITTED);

[sky, 2011/09/13 23:42:23]

DCHECK_EQ

[alexbost, 2011/09/14 21:45:30]

Done.

+
+  DictionaryValue* changed_properties = new DictionaryValue();
+  changed_properties->SetString(keys::kUrlKey, contents_->GetURL().spec());
+
+  ListValue args;
+  args.Append(Value::CreateIntegerValue(ExtensionTabUtil::GetTabId(contents_)));
+  args.Append(changed_properties);
+  args.Append(CreateValue());
+  std::string json_args;
+  base::JSONWriter::Write(&args, false, &json_args);
+
+  Tab* tab;
+  std::string error_;
+  if (!GetMap()->GetTabOfOffscreenTab(contents_, &tab, &error_)) {

[sky, 2011/09/13 23:42:23]

Should this be a DCHECK?

[alexbost, 2011/09/14 21:45:30]

Done.

+    LOG(ERROR) << error_;
+    return;
+  }
+
+  ListValue event_args;
+  event_args.Set(0, Value::CreateStringValue(keys::kEventOnUpdated));
+  event_args.Set(1, Value::CreateStringValue(json_args));
+
+  // Dispatch an onUpdated event.
+
+  // The primary use case for broadcasting the event is
+  // when the offscreen tab is generated by a test API background page.
+  if (tab->GetContents() == GetBackgroundPageTabContents(NULL)) {
+    Profile* profile = Profile::FromBrowserContext(
+        contents_->browser_context());
+    profile->GetExtensionEventRouter()->DispatchEventToRenderers(
+        keys::kEventOnUpdated, json_args, profile, GURL());
+  // Send a routed event directly to the parent tab.
+  } else {
+    tab->GetContents()->render_view_host()->process()->Send(
+        new ExtensionMsg_MessageInvoke(
+          tab->GetContents()->render_view_host()->routing_id(),

[sky, 2011/09/13 23:42:23]

indent 2 more.

[alexbost, 2011/09/14 21:45:30]

Done.

+          *(tab->GetExtensionId()),
+          keys::kDispatchEvent,
+          event_args,
+          GURL()));
+  }
+}
+
+// Tab -------------------------------------------------------------------------
+
+Tab::Tab() {}
+Tab::~Tab() {}
+
+void Tab::Init(TabContents* tab_contents, const std::string* extension_id) {
+  contents_ = tab_contents;
+  extension_id_ = extension_id;
+
+  RegisterForTabNotifications();
+}
+
+TabContents* Tab::GetContents() {

[sky, 2011/09/13 23:42:23]

inline and name contents()

[alexbost, 2011/09/14 21:45:30]

Done.

+  return contents_;
+}
+
+const std::vector<OffscreenTab*> Tab::GetOffscreenTabs() {

[sky, 2011/09/13 23:42:23]

inline and name offscreen_tabs(), also return a ref.

[alexbost, 2011/09/14 21:45:30]

Done.

+  return offscreen_tabs_;
+}
+
+const std::string* Tab::GetExtensionId() {
+  return extension_id_;
+}
+
+void Tab::AddOffscreenTab(OffscreenTab *tab) {
+  offscreen_tabs_.push_back(tab);
+}
+
+void Tab::RemoveOffscreenTab(OffscreenTab *tab) {
+  for (TabIterator it_tab = offscreen_tabs_.begin();

[sky, 2011/09/13 23:42:23]

Use std::find

[alexbost, 2011/09/14 21:45:30]

Done.

+      it_tab != offscreen_tabs_.end(); ++it_tab)
+    if (*it_tab == tab) {
+      offscreen_tabs_.erase(it_tab);
+      break;
+    }
+}
+
+void Tab::RegisterForTabNotifications() {
+  registrar_.Add(this,
+                 content::NOTIFICATION_NAV_ENTRY_COMMITTED,
+                 Source<NavigationController>(&contents_->controller()));
+
+  registrar_.Add(this,
+                 content::NOTIFICATION_TAB_CONTENTS_DESTROYED,
+                 Source<TabContents>(contents_));
+}
+
+void Tab::UnregisterForTabNotifications() {
+  registrar_.Remove(this,
+                    content::NOTIFICATION_NAV_ENTRY_COMMITTED,
+                    Source<NavigationController>(&contents_->controller()));
+
+  registrar_.Remove(this,
+                    content::NOTIFICATION_TAB_CONTENTS_DESTROYED,
+                    Source<TabContents>(contents_));
+}
+
+void Tab::Observe(const int type,
+                  const NotificationSource& source,
+                  const NotificationDetails& details) {
+  DCHECK(type == content::NOTIFICATION_NAV_ENTRY_COMMITTED ||
+         type == content::NOTIFICATION_TAB_CONTENTS_DESTROYED);
+
+  // Kill child offscreen tabs.
+  for (TabIterator it = offscreen_tabs_.begin();
+      it != offscreen_tabs_.end(); ++it)
+    delete *it;

[sky, 2011/09/13 23:42:23]

STLDeleteElements

[alexbost, 2011/09/14 21:45:30]

Done.

+
+  std::string error_;
+  if (!GetMap()->RemoveTab(ExtensionTabUtil::GetTabId(contents_), &error_)) {

[sky, 2011/09/13 23:42:23]

Again, shouldn't this be a DCHECK?

[alexbost, 2011/09/14 21:45:30]

Done.

+    LOG(ERROR) << error_;
+    return;
+  }
+
+  UnregisterForTabNotifications();

[sky, 2011/09/13 23:42:23]

Remove this, it's not needed.

[alexbost, 2011/09/14 21:45:30]

Done.

+
+  delete this;

[sky, 2011/09/13 23:42:23]

This should be first, and everything in this method should be moved to the
destructor. That way if you delete a Tab, everything is cleaned up correctly.

[alexbost, 2011/09/14 21:45:30]

Done.

+}
+
+// Map -------------------------------------------------------------------------
+
+Map::Map() {}
+Map::~Map() {}
+
+bool Map::GetOffscreenTab(const int tab_id,
+                          ExtensionFunctionDispatcher* dispatcher,
+                          Profile* profile,
+                          OffscreenTab** offscreen_tab,
+                          std::string* error_message) {
+  // Ensure that the current tab is the parent of the offscreen tab.
+  TabContents* tab_contents = NULL;
+  if (!GetCurrentTab(&tab_contents, dispatcher, profile, error_message))
+    return false;
+
+  Tab* tab = NULL;
+  if (!GetTab(ExtensionTabUtil::GetTabId(tab_contents), &tab, error_message))
+    return false;
+  TabVector offscreen_tabs = tab->GetOffscreenTabs();
+
+  for (TabIterator it = offscreen_tabs.begin();
+      it != offscreen_tabs.end(); ++it)
+    if (ExtensionTabUtil::GetTabId((*it)->GetContents()) == tab_id) {
+      *offscreen_tab = *it;
+

[sky, 2011/09/13 23:42:23]

remove this line.

[alexbost, 2011/09/14 21:45:30]

Done.

+      return true;
+    }
+
+  *error_message = ExtensionErrorUtils::FormatErrorMessage(
+      keys::kOffscreenTabNotFoundError, base::IntToString(tab_id));
+  return false;
+}
+
+bool Map::GetTab(const int tab_id, Tab** tab, std::string* error_message) {
+  if (map[tab_id] == NULL) {

[sky, 2011/09/13 23:42:23]

This inserts a NULL if tab_id isn't in the map. Instead use find.

[alexbost, 2011/09/14 21:45:30]

Done.

+    *error_message = ExtensionErrorUtils::FormatErrorMessage(
+        keys::kTabNotFoundError, base::IntToString(tab_id));
+    return false;
+  }
+
+  *tab = map[tab_id];
+
+  return true;
+}
+
+bool Map::GetTabOfOffscreenTab(TabContents* offscreen_tab_contents,
+                               Tab** tab, std::string* error_message) {
+  int offscreen_tab_id = ExtensionTabUtil::GetTabId(offscreen_tab_contents);
+
+  for (TabMap::iterator it = map.begin(); it != map.end(); ++it) {
+    TabVector offscreen_tabs = it->second->GetOffscreenTabs();
+    for (TabIterator it_tab = offscreen_tabs.begin();
+         it_tab != offscreen_tabs.end(); ++it_tab) {
+      if ((*it_tab)->GetContents() == offscreen_tab_contents) {
+        if (!GetTab(it->first, tab, error_message))
+          return false;
+
+        return true;
+      }
+    }
+  }
+
+  *error_message = ExtensionErrorUtils::FormatErrorMessage(
+      keys::kTabOfOffscreenTabNotFoundError,
+      base::IntToString(offscreen_tab_id));
+  return false;
+}
+
+bool Map::AddOffscreenTab(OffscreenTab* offscreen_tab,
+                          ExtensionFunctionDispatcher* dispatcher,
+                          Profile* profile,
+                          const std::string* ext_id,
+                          std::string* error_message) {
+  // Get parent tab.
+  TabContents* tab_contents = NULL;
+  if (!GetCurrentTab(&tab_contents, dispatcher, profile, error_message))
+    return false;
+  int tab_id = ExtensionTabUtil::GetTabId(tab_contents);
+
+  Tab* tab = NULL;
+  if (!GetTab(tab_id, &tab, error_message)) {
+    tab = map[tab_id] = new Tab();
+    tab->Init(tab_contents, ext_id);
+  }
+
+  tab->AddOffscreenTab(offscreen_tab);
+
+  return true;
+}
+
+bool Map::RemoveOffscreenTab(const int tab_id,
+                             ExtensionFunctionDispatcher* dispatcher,
+                             Profile* profile, std::string* error_message) {
+  OffscreenTab* offscreen_tab = NULL;
+  if (!GetOffscreenTab(tab_id, dispatcher, profile,
+                       &offscreen_tab, error_message))
+    return false;
+
+  Tab* tab = NULL;
+  if (!GetTabOfOffscreenTab(offscreen_tab->GetContents(), &tab, error_message))
+    return false;
+
+  tab->RemoveOffscreenTab(offscreen_tab);
+
+  // If this was the last offscreen tab for the parent tab, remove the parent.
+  if (tab->GetOffscreenTabs().empty())
+    map.erase(ExtensionTabUtil::GetTabId(tab->GetContents()));
+
+  return true;
+}
+
+bool Map::RemoveTab(const int tab_id, std::string* error_message) {
+  if (map[tab_id] == NULL) {
+    *error_message = ExtensionErrorUtils::FormatErrorMessage(
+        keys::kTabNotFoundError, base::IntToString(tab_id));
+    return false;
+  }
+
+  map.erase(tab_id);
+
+  return true;
+}
+
+}  // namespace
+
+// API functions ---------------------------------------------------------------
+
+// create ----------------------------------------------------------------------
+
+CreateOffscreenTabFunction::CreateOffscreenTabFunction() {}
+CreateOffscreenTabFunction::~CreateOffscreenTabFunction() {}
+
+bool CreateOffscreenTabFunction::RunImpl() {
+  DictionaryValue* create_props;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &create_props));
+
+  std::string url_string;
+  GURL url;
+  EXTENSION_FUNCTION_VALIDATE(
+      create_props->GetString(keys::kUrlKey, &url_string));
+  url = ResolvePossiblyRelativeURL(url_string, GetExtension());
+  if (!url.is_valid()) {
+    error_ = ExtensionErrorUtils::FormatErrorMessage(
+        keys::kInvalidUrlError, url_string);
+    return false;
+  }
+  if (IsCrashURL(url)) {
+    error_ = keys::kNoCrashBrowserError;
+    return false;
+  }
+
+  gfx::Rect window_bounds;
+  bool maximized;
+  if (!create_props->HasKey(keys::kWidthKey) ||
+      !create_props->HasKey(keys::kHeightKey)) {
+    Browser* browser = GetCurrentBrowser();
+    if (!browser) {
+      error_ = keys::kNoCurrentWindowError;
+      return false;
+    }
+
+    WindowSizer::GetBrowserWindowBounds(std::string(), gfx::Rect(),
+                                        browser, &window_bounds,
+                                        &maximized);
+  }
+
+  int width = window_bounds.width();
+  if (create_props->HasKey(keys::kWidthKey))
+    EXTENSION_FUNCTION_VALIDATE(
+        create_props->GetInteger(keys::kWidthKey, &width));
+
+  int height = window_bounds.height();
+  if (create_props->HasKey(keys::kHeightKey))
+    EXTENSION_FUNCTION_VALIDATE(
+        create_props->GetInteger(keys::kHeightKey, &height));
+
+  OffscreenTab* tab = new OffscreenTab();
+  tab->Init(url, width, height, GetExtension(), profile_, dispatcher());
+
+  if (!GetMap()->AddOffscreenTab(tab, dispatcher(), profile_,
+                                 &extension_id(), &error_)) {
+    delete tab;  // Prevent leaking of offscreen tab.
+    return false;
+  }
+
+  if (has_callback()) {
+    result_.reset(tab->CreateValue());
+    SendResponse(true);
+  }
+
+  return true;
+}
+
+// get -------------------------------------------------------------------------
+
+GetOffscreenTabFunction::GetOffscreenTabFunction() {}
+GetOffscreenTabFunction::~GetOffscreenTabFunction() {}
+
+bool GetOffscreenTabFunction::RunImpl() {
+  int tab_id;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id));
+
+  OffscreenTab* tab = NULL;
+  if (!GetMap()->
+      GetOffscreenTab(tab_id, dispatcher(), profile_, &tab, &error_)) {
+    error_ = ExtensionErrorUtils::FormatErrorMessage(
+      keys::kOffscreenTabNotFoundError, base::IntToString(tab_id));
+    return false;
+  }
+
+  result_.reset(tab->CreateValue());
+  SendResponse(true);
+
+  return true;
+}
+
+// getAll ----------------------------------------------------------------------
+
+GetAllOffscreenTabFunction::GetAllOffscreenTabFunction() {}
+GetAllOffscreenTabFunction::~GetAllOffscreenTabFunction() {}
+
+bool GetAllOffscreenTabFunction::RunImpl() {
+  TabContents* tab_contents = NULL;
+  if (!GetCurrentTab(&tab_contents, dispatcher(), profile_, &error_))
+    return false;
+
+  Tab* tab = NULL;
+  if (!GetMap()->
+      GetTab(ExtensionTabUtil::GetTabId(tab_contents), &tab, &error_))
+    return false;
+
+  TabVector offscreen_tabs = tab->GetOffscreenTabs();
+
+  ListValue* tab_list = new ListValue();
+  for (TabIterator it_tab = offscreen_tabs.begin();
+      it_tab != offscreen_tabs.end(); ++it_tab)
+    tab_list->Append((*it_tab)->CreateValue());
+
+  result_.reset(tab_list);
+  SendResponse(true);
+
+  return true;
+}
+
+// remove ----------------------------------------------------------------------
+
+RemoveOffscreenTabFunction::RemoveOffscreenTabFunction() {}
+RemoveOffscreenTabFunction::~RemoveOffscreenTabFunction() {}
+
+bool RemoveOffscreenTabFunction::RunImpl() {
+  int tab_id;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id));
+
+  OffscreenTab* tab = NULL;
+  if (!GetMap()->GetOffscreenTab(tab_id, dispatcher(), profile_, &tab, &error_))
+    return false;
+
+  if (!GetMap()->RemoveOffscreenTab(tab_id, dispatcher(), profile_, &error_))
+    return false;
+
+  delete tab;
+
+  return true;
+}
+
+// sendKeyboardEvent -----------------------------------------------------------
+
+SendKeyboardEventOffscreenTabFunction::
+    SendKeyboardEventOffscreenTabFunction() {}
+SendKeyboardEventOffscreenTabFunction::
+    ~SendKeyboardEventOffscreenTabFunction() {}
+
+bool SendKeyboardEventOffscreenTabFunction::RunImpl() {
+  int tab_id;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id));
+
+  OffscreenTab* tab = NULL;
+  if (!GetMap()->GetOffscreenTab(tab_id, dispatcher(), profile_, &tab, &error_))
+    return false;
+
+  // JavaScript KeyboardEvent.
+  DictionaryValue* dict = NULL;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &dict));
+
+  NativeWebKeyboardEvent keyboard_event;
+
+  std::string type;
+  if (dict->HasKey(keys::kKeyboardEventTypeKey)) {
+    EXTENSION_FUNCTION_VALIDATE(
+        dict->GetString(keys::kKeyboardEventTypeKey, &type));
+  } else {
+    error_ = keys::kInvalidKeyboardEventObjectError;
+    return false;
+  }
+
+  if (type.compare(keys::kKeyboardEventTypeValueKeypress) == 0) {
+    keyboard_event.type = WebInputEvent::Char;
+  } else if (type.compare(keys::kKeyboardEventTypeValueKeydown) == 0) {
+    keyboard_event.type = WebInputEvent::KeyDown;
+  } else if (type.compare(keys::kKeyboardEventTypeValueKeyup) == 0) {
+    keyboard_event.type = WebInputEvent::KeyUp;
+  } else {
+    error_ = keys::kInvalidKeyboardEventObjectError;
+    return false;
+  }
+
+  int key_code;
+  if (dict->HasKey(keys::kKeyboardEventKeyCodeKey)) {
+    EXTENSION_FUNCTION_VALIDATE(
+        dict->GetInteger(keys::kKeyboardEventKeyCodeKey, &key_code));
+  } else {
+    error_ = keys::kInvalidKeyboardEventObjectError;
+    return false;
+  }
+
+  keyboard_event.nativeKeyCode = key_code;
+  keyboard_event.windowsKeyCode = key_code;
+  keyboard_event.setKeyIdentifierFromWindowsKeyCode();
+
+  // Keypress = type character
+  if (type.compare(keys::kKeyboardEventTypeValueKeypress) == 0) {
+    int char_code;
+    if (dict->HasKey(keys::kKeyboardEventCharCodeKey)) {
+      EXTENSION_FUNCTION_VALIDATE(
+          dict->GetInteger(keys::kKeyboardEventCharCodeKey, &char_code));
+      keyboard_event.text[0] = char_code;
+      keyboard_event.unmodifiedText[0] = char_code;
+    } else {
+      error_ = keys::kInvalidKeyboardEventObjectError;
+      return false;
+    }
+  }
+
+  bool alt_key;
+  if (dict->HasKey(keys::kKeyboardEventAltKeyKey))
+    EXTENSION_FUNCTION_VALIDATE(
+        dict->GetBoolean(keys::kKeyboardEventAltKeyKey, &alt_key));
+  if (alt_key)
+    keyboard_event.modifiers |= WebInputEvent::AltKey;
+
+  bool ctrl_key;
+  if (dict->HasKey(keys::kKeyboardEventCtrlKeyKey))
+    EXTENSION_FUNCTION_VALIDATE(
+        dict->GetBoolean(keys::kKeyboardEventCtrlKeyKey, &ctrl_key));
+  if (ctrl_key)
+    keyboard_event.modifiers |= WebInputEvent::ControlKey;
+
+  bool meta_key = false;
+  if (dict->HasKey(keys::kMouseEventMetaKeyKey))
+    EXTENSION_FUNCTION_VALIDATE(
+        dict->GetBoolean(keys::kMouseEventMetaKeyKey, &meta_key));
+  if (meta_key)
+    keyboard_event.modifiers |= WebInputEvent::MetaKey;
+
+  bool shift_key;
+  if (dict->HasKey(keys::kKeyboardEventShiftKeyKey))
+    EXTENSION_FUNCTION_VALIDATE(
+        dict->GetBoolean(keys::kKeyboardEventShiftKeyKey, &shift_key));
+  if (shift_key)
+    keyboard_event.modifiers |= WebInputEvent::ShiftKey;
+
+  // Forward the event.
+  tab->GetContents()->render_view_host()->
+      ForwardKeyboardEvent(keyboard_event);
+
+  if (has_callback()) {
+    result_.reset(tab->CreateValue());
+    SendResponse(true);
+  }
+
+  return true;
+}
+
+// sendMouseEvent --------------------------------------------------------------
+
+SendMouseEventOffscreenTabFunction::SendMouseEventOffscreenTabFunction() {}
+SendMouseEventOffscreenTabFunction::~SendMouseEventOffscreenTabFunction() {}
+
+bool SendMouseEventOffscreenTabFunction::RunImpl() {
+  int tab_id;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id));
+
+  OffscreenTab* tab = NULL;
+  if (!GetMap()->GetOffscreenTab(tab_id, dispatcher(), profile_, &tab, &error_))
+    return false;
+
+  // JavaScript MouseEvent.
+  DictionaryValue* dict = NULL;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &dict));
+
+  std::string type;
+  if (dict->HasKey(keys::kMouseEventTypeKey)) {
+    EXTENSION_FUNCTION_VALIDATE(
+        dict->GetString(keys::kMouseEventTypeKey, &type));
+  } else {
+    error_ = keys::kInvalidMouseEventObjectError;
+    return false;
+  }
+
+  if (type.compare(keys::kMouseEventTypeValueMousewheel) == 0) {
+    WebKit::WebMouseWheelEvent wheel_event;
+
+    wheel_event.type = WebInputEvent::MouseWheel;
+
+    if (dict->HasKey(keys::kMouseEventWheelDeltaXKey) &&
+        dict->HasKey(keys::kMouseEventWheelDeltaYKey)) {
+      int delta_x, delta_y;
+      EXTENSION_FUNCTION_VALIDATE(
+          dict->GetInteger(keys::kMouseEventWheelDeltaXKey, &delta_x));
+      EXTENSION_FUNCTION_VALIDATE(
+          dict->GetInteger(keys::kMouseEventWheelDeltaYKey, &delta_y));
+      wheel_event.deltaX = delta_x;
+      wheel_event.deltaY = delta_y;
+    } else {
+      error_ = keys::kInvalidMouseEventObjectError;
+      return false;
+    }
+
+    // Forward the event.
+    tab->GetContents()->render_view_host()->ForwardWheelEvent(wheel_event);
+  } else {
+    WebKit::WebMouseEvent mouse_event;
+
+    if (type.compare(keys::kMouseEventTypeValueMousedown) == 0 ||
+        type.compare(keys::kMouseEventTypeValueClick) == 0) {
+      mouse_event.type = WebKit::WebInputEvent::MouseDown;
+    } else if (type.compare(keys::kMouseEventTypeValueMouseup) == 0) {
+      mouse_event.type = WebKit::WebInputEvent::MouseUp;
+    } else if (type.compare(keys::kMouseEventTypeValueMousemove) == 0) {
+      mouse_event.type = WebKit::WebInputEvent::MouseMove;
+    } else {
+      error_ = keys::kInvalidMouseEventObjectError;
+      return false;
+    }
+
+    int button;
+    if (dict->HasKey(keys::kMouseEventButtonKey)) {
+      EXTENSION_FUNCTION_VALIDATE(
+          dict->GetInteger(keys::kMouseEventButtonKey, &button));
+    } else {
+      error_ = keys::kInvalidMouseEventObjectError;
+      return false;
+    }
+
+    if (button == keys::kMouseEventButtonValueLeft) {
+      mouse_event.button = WebKit::WebMouseEvent::ButtonLeft;
+    } else if (button == keys::kMouseEventButtonValueMiddle) {
+      mouse_event.button = WebKit::WebMouseEvent::ButtonMiddle;
+    } else if (button == keys::kMouseEventButtonValueRight) {
+      mouse_event.button = WebKit::WebMouseEvent::ButtonRight;
+    } else {
+      error_ = keys::kInvalidMouseEventObjectError;
+      return false;
+    }
+
+    if (HasOptionalArgument(2) && HasOptionalArgument(3)) {
+      EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(2, &mouse_event.x));
+      EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(3, &mouse_event.y));
+    } else {
+      error_ = keys::kNoMouseCoordinatesError;
+      return false;
+    }
+
+    bool alt_key = false;
+    if (dict->HasKey(keys::kMouseEventAltKeyKey))
+      EXTENSION_FUNCTION_VALIDATE(
+          dict->GetBoolean(keys::kMouseEventAltKeyKey, &alt_key));
+    if (alt_key)
+      mouse_event.modifiers |= WebInputEvent::AltKey;
+
+    bool ctrl_key = false;
+    if (dict->HasKey(keys::kMouseEventCtrlKeyKey))
+      EXTENSION_FUNCTION_VALIDATE(
+          dict->GetBoolean(keys::kMouseEventCtrlKeyKey, &ctrl_key));
+    if (ctrl_key)
+      mouse_event.modifiers |= WebInputEvent::ControlKey;
+
+    bool meta_key = false;
+    if (dict->HasKey(keys::kMouseEventMetaKeyKey))
+      EXTENSION_FUNCTION_VALIDATE(
+          dict->GetBoolean(keys::kMouseEventMetaKeyKey, &meta_key));
+    if (meta_key)
+      mouse_event.modifiers |= WebInputEvent::MetaKey;
+
+    bool shift_key = false;
+    if (dict->HasKey(keys::kMouseEventShiftKeyKey))
+      EXTENSION_FUNCTION_VALIDATE(
+          dict->GetBoolean(keys::kMouseEventShiftKeyKey, &shift_key));
+    if (shift_key)
+      mouse_event.modifiers |= WebInputEvent::ShiftKey;
+
+    mouse_event.clickCount = 1;
+
+    // Forward the event.
+    tab->GetContents()->render_view_host()->ForwardMouseEvent(mouse_event);
+
+    // If the event is a click,
+    // fire a mouseup event in addition to the mousedown.
+    if (type.compare(keys::kMouseEventTypeValueClick) == 0) {
+      mouse_event.type = WebKit::WebInputEvent::MouseUp;
+      tab->GetContents()->render_view_host()->ForwardMouseEvent(mouse_event);
+    }
+  }
+
+  if (has_callback()) {
+    result_.reset(tab->CreateValue());
+    SendResponse(true);
+  }
+
+  return true;
+}
+
+// toDataUrl -------------------------------------------------------------------
+
+ToDataUrlOffscreenTabFunction::ToDataUrlOffscreenTabFunction() {}
+ToDataUrlOffscreenTabFunction::~ToDataUrlOffscreenTabFunction() {}
+
+// TODO(alexbost): Needs refactoring. Similar method in extension_tabs_module.
+// TODO(alexbost): We want to optimize this function in order to get more image
+// updates on the browser side. One improvement would be to implement another
+// hash map in order to get offscreen tabs in O(1).
+bool ToDataUrlOffscreenTabFunction::RunImpl() {
+  int tab_id;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id));
+
+
+  OffscreenTab* tab = NULL;
+  if (!GetMap()->GetOffscreenTab(tab_id, dispatcher(), profile_, &tab, &error_))
+    return false;
+
+  image_format_ = FORMAT_JPEG;  // Default format is JPEG.
+  image_quality_ = kDefaultQuality;  // Default quality setting.
+
+  if (HasOptionalArgument(1)) {
+    DictionaryValue* options;
+    EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &options));
+
+    if (options->HasKey(keys::kFormatKey)) {
+      std::string format;
+      EXTENSION_FUNCTION_VALIDATE(
+          options->GetString(keys::kFormatKey, &format));
+
+      if (format == keys::kFormatValueJpeg) {
+        image_format_ = FORMAT_JPEG;
+      } else if (format == keys::kFormatValuePng) {
+        image_format_ = FORMAT_PNG;
+      } else {
+        // Schema validation should make this unreachable.
+        EXTENSION_FUNCTION_VALIDATE(0);
+      }
+    }
+
+    if (options->HasKey(keys::kQualityKey)) {
+      EXTENSION_FUNCTION_VALIDATE(
+          options->GetInteger(keys::kQualityKey, &image_quality_));
+    }
+  }
+
+  // captureVisibleTab() can return an image containing sensitive information
+  // that the browser would otherwise protect.  Ensure the extension has
+  // permission to do this.
+  if (!GetExtension()->
+      CanCaptureVisiblePage(tab->GetContents()->GetURL(), &error_))
+    return false;
+
+// The backing store approach works on Linux but not on Mac.
+// TODO(alexbost): Test on Windows
+#if !defined(OS_MACOSX)
+  RenderViewHost* render_view_host = tab->GetContents()->render_view_host();
+
+  // If a backing store is cached for the tab we want to capture,
+  // and it can be copied into a bitmap, then use it to generate the image.
+  BackingStore* backing_store = render_view_host->GetBackingStore(false);
+  if (backing_store && CaptureSnapshotFromBackingStore(backing_store))
+    return true;
+#endif
+
+  // Ask the renderer for a snapshot of the tab.
+  TabContentsWrapper* tab_wrapper =
+      TabContentsWrapper::GetCurrentWrapperForContents(tab->GetContents());
+  tab_wrapper->CaptureSnapshot();
+  registrar_.Add(this,
+               chrome::NOTIFICATION_TAB_SNAPSHOT_TAKEN,
+               Source<TabContentsWrapper>(tab_wrapper));
+
+  AddRef();  // Balanced in ToDataUrlOffscreenTabFunction::Observe().
+
+  return true;
+}
+
+// TODO(alexbost): Needs refactoring. Similar method in extension_tabs_module.
+// Build the image of a tab's contents out of a backing store.
+// This may fail if we can not copy a backing store into a bitmap.
+// For example, some uncommon X11 visual modes are not supported by
+// CopyFromBackingStore().
+bool ToDataUrlOffscreenTabFunction::CaptureSnapshotFromBackingStore(
+    BackingStore* backing_store) {
+
+  skia::PlatformCanvas temp_canvas;
+  if (!backing_store->CopyFromBackingStore(gfx::Rect(backing_store->size()),
+                                           &temp_canvas)) {
+    return false;
+  }
+  VLOG(1) << "captureVisibleTab() got image from backing store.";
+
+  SendResultFromBitmap(
+      skia::GetTopDevice(temp_canvas)->accessBitmap(false));
+  return true;
+}
+
+// TODO(alexbost): Needs refactoring. Similar method in extension_tabs_module.
+void ToDataUrlOffscreenTabFunction::Observe(const int type,
+                                            const NotificationSource& source,
+                                           const NotificationDetails& details) {
+  DCHECK(type == chrome::NOTIFICATION_TAB_SNAPSHOT_TAKEN);
+
+  const SkBitmap *screen_capture = Details<const SkBitmap>(details).ptr();
+  const bool error = screen_capture->empty();
+
+  if (error) {
+    error_ = keys::kInternalVisibleTabCaptureError;
+    SendResponse(false);
+  } else {
+    VLOG(1) << "Got image from renderer.";
+    SendResultFromBitmap(*screen_capture);
+  }
+
+  Release();  // Balanced in ToDataUrlOffscreenTabFunction::RunImpl().
+}
+
+// TODO(alexbost): Needs refactoring. Similar method in extension_tabs_module.
+// Turn a bitmap of the screen into an image, set that image as the result,
+// and call SendResponse().
+void ToDataUrlOffscreenTabFunction::SendResultFromBitmap(
+    const SkBitmap& screen_capture) {
+  std::vector<unsigned char> data;
+  SkAutoLockPixels screen_capture_lock(screen_capture);
+  bool encoded = false;
+  std::string mime_type;
+  switch (image_format_) {
+    case FORMAT_JPEG:
+      encoded = gfx::JPEGCodec::Encode(
+          reinterpret_cast<unsigned char*>(screen_capture.getAddr32(0, 0)),
+          gfx::JPEGCodec::FORMAT_SkBitmap,
+          screen_capture.width(),
+          screen_capture.height(),
+          static_cast<int>(screen_capture.rowBytes()),
+          image_quality_,
+          &data);
+      mime_type = keys::kMimeTypeJpeg;
+      break;
+    case FORMAT_PNG:
+      encoded = gfx::PNGCodec::EncodeBGRASkBitmap(
+          screen_capture,
+          true,  // Discard transparency.
+          &data);
+      mime_type = keys::kMimeTypePng;
+      break;
+    default:
+      NOTREACHED() << "Invalid image format.";
+  }
+
+  if (!encoded) {
+    error_ = keys::kInternalVisibleTabCaptureError;
+    SendResponse(false);
+    return;
+  }
+
+  std::string base64_result;
+  base::StringPiece stream_as_string(
+      reinterpret_cast<const char*>(vector_as_array(&data)), data.size());
+
+  base::Base64Encode(stream_as_string, &base64_result);
+  base64_result.insert(0, base::StringPrintf("data:%s;base64,",
+                                             mime_type.c_str()));
+  result_.reset(new StringValue(base64_result));
+  SendResponse(true);
+}
+
+// update ----------------------------------------------------------------------
+
+UpdateOffscreenTabFunction::UpdateOffscreenTabFunction() {}
+UpdateOffscreenTabFunction::~UpdateOffscreenTabFunction() {}
+
+// TODO(alexbost): Needs refactoring. Similar method in extension_tabs_module.
+bool UpdateOffscreenTabFunction::RunImpl() {
+  int tab_id;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id));
+
+  OffscreenTab* tab = NULL;
+  if (!GetMap()->GetOffscreenTab(tab_id, dispatcher(), profile_, &tab, &error_))
+    return false;
+
+  DictionaryValue* update_props;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &update_props));
+
+  // Url
+  if (update_props->HasKey(keys::kUrlKey)) {
+    std::string url_string;
+    GURL url;
+    EXTENSION_FUNCTION_VALIDATE(
+        update_props->GetString(keys::kUrlKey, &url_string));
+    url = ResolvePossiblyRelativeURL(url_string, GetExtension());
+    if (!url.is_valid()) {
+      error_ = ExtensionErrorUtils::FormatErrorMessage(
+          keys::kInvalidUrlError, url_string);
+      return false;
+    }
+    if (IsCrashURL(url)) {
+      error_ = keys::kNoCrashBrowserError;
+      return false;
+    }
+
+    // JavaScript URLs can do the same kinds of things as cross-origin XHR, so
+    // we need to check host permissions before allowing them.
+    if (url.SchemeIs(chrome::kJavaScriptScheme)) {
+      if (!GetExtension()->CanExecuteScriptOnPage(
+          tab->GetContents()->GetURL(), NULL, &error_)) {
+        return false;
+      }
+
+      ExtensionMsg_ExecuteCode_Params params;
+      params.request_id = request_id();
+      params.extension_id = extension_id();
+      params.is_javascript = true;
+      params.code = url.path();
+      params.all_frames = false;
+      params.in_main_world = true;
+
+      RenderViewHost* render_view_host =
+          tab->GetContents()->render_view_host();
+      render_view_host->Send(
+          new ExtensionMsg_ExecuteCode(render_view_host->routing_id(),
+                                       params));
+
+      Observe(tab->GetContents());
+      AddRef();  // balanced in Observe()
+
+      return true;
+    }
+
+    tab->SetUrl(url);
+
+    // The URL of a tab contents never actually changes to a JavaScript URL, so
+    // this check only makes sense in other cases.
+    if (!url.SchemeIs(chrome::kJavaScriptScheme))
+      DCHECK_EQ(url.spec(), tab->GetContents()->GetURL().spec());
+  }
+
+  // Width and height
+  if (update_props->HasKey(keys::kWidthKey) ||
+      update_props->HasKey(keys::kHeightKey)) {
+    int width;
+    if (update_props->HasKey(keys::kWidthKey))
+      EXTENSION_FUNCTION_VALIDATE(
+          update_props->GetInteger(keys::kWidthKey, &width));
+    else
+      GetTabWidth(tab->GetContents());
+
+    int height;
+    if (update_props->HasKey(keys::kHeightKey))
+      EXTENSION_FUNCTION_VALIDATE(
+          update_props->GetInteger(keys::kHeightKey, &height));
+    else
+      GetTabHeight(tab->GetContents());
+
+    tab->SetSize(width, height);
+  }
+
+  // Callback
+  if (has_callback()) {
+    result_.reset(tab->CreateValue());
+    SendResponse(true);
+  }
+
+  return true;
+}
+
+// TODO(alexbost): Needs refactoring. Similar method in extension_tabs_module.
+bool UpdateOffscreenTabFunction::OnMessageReceived(
+    const IPC::Message& message) {
+  if (message.type() != ExtensionHostMsg_ExecuteCodeFinished::ID)
+    return false;
+
+  int message_request_id;
+  void* iter = NULL;
+  if (!message.ReadInt(&iter, &message_request_id)) {
+    NOTREACHED() << "malformed extension message";
+    return true;
+  }
+
+  if (message_request_id != request_id())
+    return false;
+
+  IPC_BEGIN_MESSAGE_MAP(UpdateOffscreenTabFunction, message)
+    IPC_MESSAGE_HANDLER(ExtensionHostMsg_ExecuteCodeFinished,
+                        OnExecuteCodeFinished)
+  IPC_END_MESSAGE_MAP()
+  return true;
+}
+
+// TODO(alexbost): Needs refactoring. Similar method in extension_tabs_module.
+void UpdateOffscreenTabFunction::OnExecuteCodeFinished(int request_id,
+                                              bool success,
+                                              const std::string& error) {
+  if (!error.empty()) {
+    CHECK(!success);
+    error_ = error;
+  }
+
+  SendResponse(success);
+
+  Observe(NULL);
+  Release();  // balanced in Execute()
+}
+