Re-land alexbost's experimental offscreenTabs API.

chrome/browser/extensions/api/offscreen_tabs/offscreen_tabs_api.cc

Index: chrome/browser/extensions/api/offscreen_tabs/offscreen_tabs_api.cc
diff --git a/chrome/browser/extensions/api/offscreen_tabs/offscreen_tabs_api.cc b/chrome/browser/extensions/api/offscreen_tabs/offscreen_tabs_api.cc
new file mode 100644
index 0000000000000000000000000000000000000000..5d386210fe61115542febc963a9effc5bee406d5
--- /dev/null
+++ b/chrome/browser/extensions/api/offscreen_tabs/offscreen_tabs_api.cc
@@ -0,0 +1,838 @@
+// Copyright (c) 2012 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/api/offscreen_tabs/offscreen_tabs_api.h"
+
+#include <algorithm>
+#include <vector>
+
+#include "base/hash_tables.h"
+#include "base/json/json_writer.h"
+#include "base/memory/scoped_vector.h"
+#include "base/lazy_instance.h"
+#include "base/string_number_conversions.h"
+#include "base/string_util.h"
+#include "base/values.h"
+#include "chrome/browser/extensions/api/offscreen_tabs/offscreen_tabs_constants.h"
+#include "chrome/browser/extensions/extension_event_names.h"
+#include "chrome/browser/extensions/extension_event_router.h"
+#include "chrome/browser/extensions/extension_function_dispatcher.h"
+#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/extension_tab_util.h"
+#include "chrome/browser/extensions/extension_tabs_module.h"
+#include "chrome/browser/extensions/extension_tabs_module_constants.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/browser.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/render_view_host.h"
+#include "content/public/browser/navigation_controller.h"
+#include "content/public/browser/notification_details.h"
+#include "content/public/browser/notification_source.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/browser/web_contents_view.h"
+
+using content::NavigationController;
+using content::NotificationDetails;
+using content::NotificationSource;
+using content::WebContents;
+using WebKit::WebInputEvent;
+using extensions::tabs_module::ResolvePossiblyRelativeURL;
+
+namespace keys = extensions::offscreen_tabs_constants;
+namespace tabs_keys = extension_tabs_module_constants;
+namespace events = extension_event_names;
+
+namespace {
+
+class ParentTab;
+
+// This class is responsible for the life cycle of an offscreen tab.
+class OffscreenTab : public content::NotificationObserver {
+ public:
+  OffscreenTab();
+  virtual ~OffscreenTab();
+  void Init(const GURL& url,
+            const int width,
+            const int height,
+            Profile* profile,
+            ParentTab* parent_tab);
+
+  TabContentsWrapper* tab_contents() { return tab_contents_wrapper_.get(); }
+  WebContents* web_contents() {
+    return tab_contents()->web_contents();
+  }
+  int GetID() { return ExtensionTabUtil::GetTabId(web_contents()); }
+  ParentTab* parent_tab() { return parent_tab_; }
+
+  // Creates a representation of this OffscreenTab for use by the API methods.
+  // Passes ownership to the caller.
+  DictionaryValue* CreateValue();
+
+  // Navigates the tab to the |url|.
+  void NavigateToURL(const GURL& url) {
+    web_contents()->GetController().LoadURL(
+        url, content::Referrer(), content::PAGE_TRANSITION_LINK, std::string());
+  }
+
+  // Adjusts the tab's dimensions to the specified |width| and |height|.
+  void SetSize(int width, int height) {
+    // TODO(jstritar): this doesn't seem to work on ChromeOS.
+    web_contents()->GetView()->SizeContents(gfx::Size(width, height));
+  }
+
+ private:
+  virtual void Observe(int type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details) OVERRIDE;
+
+  content::NotificationRegistrar registrar_;
+  scoped_ptr<TabContentsWrapper> tab_contents_wrapper_;
+  ParentTab* parent_tab_;
+
+  DISALLOW_COPY_AND_ASSIGN(OffscreenTab);
+};
+
+typedef ScopedVector<OffscreenTab> OffscreenTabs;
+
+// Holds info about a tab that has spawned at least one offscreen tab.
+// Each ParentTab keeps track of its child offscreen tabs. The ParentTab is also
+// responsible for killing its children when it navigates away or gets closed.
+class ParentTab : public content::NotificationObserver {
+ public:
+  ParentTab();
+  virtual ~ParentTab();
+  void Init(WebContents* web_contents,
+            const std::string& extension_id);
+
+  TabContentsWrapper* tab_contents() { return tab_contents_wrapper_; }
+  int GetID() { return ExtensionTabUtil::GetTabId(web_contents()); }
+  WebContents* web_contents() {
+    return tab_contents()->web_contents();
+  }
+
+  // Returns the offscreen tabs spawned by this tab.
+  const OffscreenTabs& offscreen_tabs() { return offscreen_tabs_; }
+  const std::string& extension_id() const { return extension_id_; }
+
+  // Tab takes ownership of OffscreenTab.
+  void AddOffscreenTab(OffscreenTab *tab);
+
+  // Removes the offscreen |tab| and returns true if this parent has no more
+  // offscreen tabs.
+  bool RemoveOffscreenTab(OffscreenTab *tab);
+
+ private:
+  virtual void Observe(int type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details) OVERRIDE;
+
+  content::NotificationRegistrar registrar_;
+
+  TabContentsWrapper* tab_contents_wrapper_;
+  OffscreenTabs offscreen_tabs_;
+  std::string extension_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(ParentTab);
+};
+
+// This map keeps track of all tabs that are happy parents of offscreen tabs.
+class OffscreenTabMap {
+ public:
+  OffscreenTabMap();
+  ~OffscreenTabMap();
+
+  // Returns true if this map tracks |parent_tab|.
+  bool ContainsTab(ParentTab* parent_tab);
+
+  // Gets an offscreen tab by ID.
+  bool GetOffscreenTab(const int offscreen_tab_id,
+                       UIThreadExtensionFunction* function,
+                       OffscreenTab** offscreen_tab,
+                       std::string* error);
+
+  // Gets a parent tab from its contents for the given extension id.
+  // Returns NULL if no such tab exists.
+  ParentTab* GetParentTab(WebContents* parent_contents,
+                          const std::string& extension_id);
+
+  // Creates a new offscreen tab and a mapping between the |parent_tab| and
+  // the offscreen tab. Takes ownership of |parent_tab|, if it does not already
+  // have a mapping for it.
+  OffscreenTab* CreateOffscreenTab(ParentTab* parent_tab,
+                                   const GURL& url,
+                                   const int width,
+                                   const int height,
+                                   const std::string& extension_id);
+
+  // Removes the mapping between a parent tab and an offscreen tab.
+  // May cause the OffscreenTab object associated with the parent to be deleted.
+  bool RemoveOffscreenTab(const int offscreen_tab_id,
+                          UIThreadExtensionFunction* function,
+                          std::string* error);
+
+  // Removes and deletes |parent_tab| and all it's offscreen tabs.
+  void RemoveParentTab(ParentTab* parent_tab);
+
+ private:
+  typedef base::hash_map<int, ParentTab*> TabMap;
+  TabMap map_;
+
+  DISALLOW_COPY_AND_ASSIGN(OffscreenTabMap);
+};
+
+// TODO(jstritar): This isn't multi-profile aware.

[asargent_no_longer_on_chrome, 2012/03/01 00:20:05]

lolwut? Do you just mean that this should be hung as a ProfileKeyedService or
something instead of using a LazyInstance?

[jstritar, 2012/03/12 14:53:06]

Actually, there's no problem here. I was thinking we needed one per profile, but
we key off the tab ids which are unique.

+static base::LazyInstance<OffscreenTabMap> g_offscreen_tab_map =
+    LAZY_INSTANCE_INITIALIZER;
+
+// Gets the map of parent tabs to offscreen tabs.
+OffscreenTabMap* GetMap() {
+  return &g_offscreen_tab_map.Get();
+}
+
+// Gets the WebContents of the tab that instantiated the extension API call.
+// Returns NULL if there was an error.
+// Note that you can't create offscreen tabs from background pages, since they

[asargent_no_longer_on_chrome, 2012/03/01 00:20:05]

Awesome, I like this restriction to help avoid leaks of offscreen tabs. Please
mention this in the documentation.

[jstritar, 2012/03/12 14:53:06]

I updated the create method documentation for now.

+// don't have an associated WebContents. The life time of offscreen tabs is tied

[asargent_no_longer_on_chrome, 2012/03/01 00:20:05]

nit: "life time" -> "lifetime"

[jstritar, 2012/03/12 14:53:06]

Done.

+// to their creating tab, so requiring visible tabs as the parent helps prevent
+// offscreen tab leaking.
+WebContents* GetCurrentWebContents(UIThreadExtensionFunction* function,
+                                   std::string* error) {
+  WebContents* web_contents =
+      function->dispatcher()->delegate()->GetAssociatedWebContents();
+  if (web_contents)
+    return web_contents;
+
+  *error = keys::kCurrentTabNotFound;
+  return NULL;
+}
+
+OffscreenTab::OffscreenTab() : parent_tab_(NULL) {}
+OffscreenTab::~OffscreenTab() {}
+
+void OffscreenTab::Init(const GURL& url,
+                        const int width,
+                        const int height,
+                        Profile* profile,
+                        ParentTab* parent_tab) {
+  // Create the offscreen tab.
+  WebContents* web_contents = WebContents::Create(
+      profile, NULL, MSG_ROUTING_NONE, NULL, NULL);
+  tab_contents_wrapper_.reset(new TabContentsWrapper(web_contents));
+
+  // Setting the size starts the renderer.
+  SetSize(width, height);
+  NavigateToURL(url);
+
+  parent_tab_ = parent_tab;
+
+  // Register for tab notifications.
+  registrar_.Add(
+      this,
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED,
+      content::Source<NavigationController>(&(web_contents->GetController())));
+}
+
+DictionaryValue* OffscreenTab::CreateValue() {
+  DictionaryValue* result = new DictionaryValue();
+  result->SetInteger(
+      tabs_keys::kIdKey, ExtensionTabUtil::GetTabId(web_contents()));
+  result->SetString(tabs_keys::kUrlKey, web_contents()->GetURL().spec());
+  result->SetInteger(tabs_keys::kWidthKey,
+      web_contents()->GetView()->GetContainerSize().width());
+  result->SetInteger(tabs_keys::kHeightKey,
+      web_contents()->GetView()->GetContainerSize().height());
+  return result;
+}
+
+void OffscreenTab::Observe(int type,
+                           const NotificationSource& source,
+                           const NotificationDetails& details) {
+  CHECK_EQ(content::NOTIFICATION_NAV_ENTRY_COMMITTED, type);
+
+  DictionaryValue* changed_properties = new DictionaryValue();
+  changed_properties->SetString(
+      tabs_keys::kUrlKey, web_contents()->GetURL().spec());
+
+  ListValue args;
+  args.Append(Value::CreateIntegerValue(
+      ExtensionTabUtil::GetTabId(web_contents())));
+  args.Append(changed_properties);
+  args.Append(CreateValue());
+  std::string json_args;
+  base::JSONWriter::Write(&args, false, &json_args);
+
+  // The event router only dispatches the event to renderers listening for the
+  // event.
+  Profile* profile = parent_tab_->tab_contents()->profile();
+  profile->GetExtensionEventRouter()->DispatchEventToRenderers(
+      events::kOnOffscreenTabUpdated, json_args, profile, GURL());
+}
+
+ParentTab::ParentTab() : tab_contents_wrapper_(NULL) {}
+ParentTab::~ParentTab() {}
+
+void ParentTab::Init(WebContents* web_contents,
+                     const std::string& extension_id) {
+  CHECK(web_contents);
+
+  extension_id_ = extension_id;
+  tab_contents_wrapper_ =
+      TabContentsWrapper::GetCurrentWrapperForContents(web_contents);
+
+  CHECK(tab_contents_wrapper_);
+
+  // Register for tab notifications.
+  registrar_.Add(
+      this,
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED,
+      content::Source<NavigationController>(&(web_contents->GetController())));
+  registrar_.Add(
+      this,
+      content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
+      content::Source<WebContents>(web_contents));
+}
+
+void ParentTab::AddOffscreenTab(OffscreenTab *offscreen_tab) {
+  offscreen_tabs_.push_back(offscreen_tab);
+}
+
+bool ParentTab::RemoveOffscreenTab(OffscreenTab *offscreen_tab) {
+  OffscreenTabs::iterator it_tab = std::find(
+      offscreen_tabs_.begin(), offscreen_tabs_.end(), offscreen_tab);
+  offscreen_tabs_.erase(it_tab);
+  return offscreen_tabs_.empty();
+}
+
+void ParentTab::Observe(int type,
+                        const NotificationSource& source,
+                        const NotificationDetails& details) {
+  CHECK(type == content::NOTIFICATION_NAV_ENTRY_COMMITTED ||
+        type == content::NOTIFICATION_WEB_CONTENTS_DESTROYED);
+  GetMap()->RemoveParentTab(this);
+}
+
+OffscreenTabMap::OffscreenTabMap() {}
+OffscreenTabMap::~OffscreenTabMap() {
+  STLDeleteContainerPairSecondPointers(map_.begin(), map_.end());

[asargent_no_longer_on_chrome, 2012/03/01 00:20:05]

Optional suggestion: if you used linked_ptr<> instead of a raw pointer as the
value in the map, you get this for free. That would also let you get rid of the
RemoveParentTab method if favor of just calling erase directly. 

[jstritar, 2012/03/12 14:53:06]

Nice, done. I ended up still needing RemoveParentTab since it's called from
ParentTab, but now it just calls std::map::erase.

+}
+
+bool OffscreenTabMap::ContainsTab(ParentTab* parent_tab) {
+  return map_.find(parent_tab->GetID()) != map_.end();
+}
+
+bool OffscreenTabMap::GetOffscreenTab(const int offscreen_tab_id,
+                                      UIThreadExtensionFunction* function,
+                                      OffscreenTab** offscreen_tab,
+                                      std::string* error) {
+  // Ensure that the current tab is the parent of the offscreen tab.
+  WebContents* web_contents = GetCurrentWebContents(function, error);
+  if (!web_contents)
+    return false;
+
+  ParentTab* parent_tab = GetMap()->GetParentTab(
+      web_contents, function->extension_id());
+  if (parent_tab) {
+    const OffscreenTabs& tabs = parent_tab->offscreen_tabs();
+    for (OffscreenTabs::const_iterator i = tabs.begin(); i != tabs.end(); ++i) {
+      if ((*i)->GetID() == offscreen_tab_id) {
+        *offscreen_tab = *i;
+        return true;
+      }
+    }
+  }
+
+  *error = ExtensionErrorUtils::FormatErrorMessage(
+      keys::kOffscreenTabNotFoundError, base::IntToString(offscreen_tab_id));
+  return false;
+}
+
+ParentTab* OffscreenTabMap::GetParentTab(WebContents* parent_contents,
+                                         const std::string& extension_id) {
+  CHECK(parent_contents);
+
+  int parent_tab_id = ExtensionTabUtil::GetTabId(parent_contents);
+  if (map_.find(parent_tab_id) == map_.end())
+    return NULL;
+
+  return map_[parent_tab_id];
+}
+
+OffscreenTab* OffscreenTabMap::CreateOffscreenTab(ParentTab* parent_tab,
+                                                  const GURL& url,
+                                                  const int width,
+                                                  const int height,
+                                                  const std::string& ext_id) {
+  CHECK(parent_tab);
+
+  // Assume ownership of |parent_tab| if we haven't already.
+  if (!ContainsTab(parent_tab))
+    map_[ExtensionTabUtil::GetTabId(parent_tab->web_contents())] = parent_tab;
+
+  OffscreenTab* offscreen_tab = new OffscreenTab();
+  offscreen_tab->Init(
+      url, width, height, parent_tab->tab_contents()->profile(), parent_tab);
+  parent_tab->AddOffscreenTab(offscreen_tab);
+
+  return offscreen_tab;
+}
+
+bool OffscreenTabMap::RemoveOffscreenTab(
+    const int offscreen_tab_id,
+    UIThreadExtensionFunction* function,
+    std::string* error) {
+  OffscreenTab* offscreen_tab = NULL;
+  if (!GetOffscreenTab(offscreen_tab_id, function, &offscreen_tab, error))
+    return false;
+
+  // Tell the parent tab to remove the offscreen tab, and then remove the
+  // parent tab if there are no more children.
+  ParentTab* parent_tab = offscreen_tab->parent_tab();
+  if (parent_tab->RemoveOffscreenTab(offscreen_tab))
+    RemoveParentTab(parent_tab);
+
+  return true;
+}
+
+void OffscreenTabMap::RemoveParentTab(ParentTab* parent_tab) {
+  CHECK(parent_tab);
+  CHECK(ContainsTab(parent_tab));
+
+  map_.erase(parent_tab->GetID());
+  delete parent_tab;
+}
+
+bool CopyModifiers(const DictionaryValue* js_event,
+                   WebInputEvent* event) {
+  bool alt_key = false;
+  if (js_event->HasKey(keys::kEventAltKeyKey)) {
+    if (!js_event->GetBoolean(keys::kEventAltKeyKey, &alt_key))
+      return false;
+  }
+  if (alt_key)
+    event->modifiers |= WebInputEvent::AltKey;
+
+  bool ctrl_key = false;
+  if (js_event->HasKey(keys::kEventCtrlKeyKey)) {
+    if (!js_event->GetBoolean(keys::kEventCtrlKeyKey, &ctrl_key))
+      return false;
+  }
+  if (ctrl_key)
+    event->modifiers |= WebInputEvent::ControlKey;
+
+  bool meta_key = false;
+  if (js_event->HasKey(keys::kEventMetaKeyKey)) {
+    if (!js_event->GetBoolean(keys::kEventMetaKeyKey, &meta_key))
+      return false;
+  }
+  if (meta_key)
+    event->modifiers |= WebInputEvent::MetaKey;
+
+  bool shift_key;
+  if (js_event->HasKey(keys::kEventShiftKeyKey)) {
+    if (!js_event->GetBoolean(keys::kEventShiftKeyKey, &shift_key))
+      return false;
+  }
+  if (shift_key)
+    event->modifiers |= WebInputEvent::ShiftKey;
+  return true;
+}
+
+}  // namespace
+
+CreateOffscreenTabFunction::CreateOffscreenTabFunction() {}
+CreateOffscreenTabFunction::~CreateOffscreenTabFunction() {}
+
+bool CreateOffscreenTabFunction::RunImpl() {
+  DictionaryValue* create_props;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &create_props));
+
+  std::string url_string;
+  EXTENSION_FUNCTION_VALIDATE(create_props->GetString(
+      tabs_keys::kUrlKey, &url_string));
+
+  GURL url;
+  url = ResolvePossiblyRelativeURL(url_string, GetExtension());
+  if (!url.is_valid()) {
+    error_ = ExtensionErrorUtils::FormatErrorMessage(
+        tabs_keys::kInvalidUrlError, url_string);
+    return false;
+  }
+
+  if (extensions::tabs_module::IsCrashURL(url)) {
+    error_ = tabs_keys::kNoCrashBrowserError;
+    return false;
+  }
+
+  gfx::Rect window_bounds;
+  Browser* browser = GetCurrentBrowser();
+  if (!browser) {
+    error_ = tabs_keys::kNoCurrentWindowError;
+    return false;
+  }
+
+  WindowSizer::GetBrowserWindowBounds(
+      std::string(), gfx::Rect(), browser, &window_bounds);
+
+  int width = window_bounds.width();
+  if (create_props->HasKey(tabs_keys::kWidthKey))
+    EXTENSION_FUNCTION_VALIDATE(
+        create_props->GetInteger(tabs_keys::kWidthKey, &width));
+
+  int height = window_bounds.height();
+  if (create_props->HasKey(tabs_keys::kHeightKey))
+    EXTENSION_FUNCTION_VALIDATE(
+        create_props->GetInteger(tabs_keys::kHeightKey, &height));
+
+
+  // Add the offscreen tab to the map so we don't lose track of it.
+  WebContents* web_contents = GetCurrentWebContents(this, &error_);
+  if (!web_contents)
+    return false;
+
+  ParentTab* parent_tab = GetMap()->GetParentTab(web_contents, extension_id());
+  if (!parent_tab) {
+    // Ownership is passed to the OffscreenMap in CreateOffscreenTab.
+    parent_tab = new ParentTab();
+    parent_tab->Init(web_contents, extension_id());
+  }
+
+  OffscreenTab* offscreen_tab = GetMap()->CreateOffscreenTab(

[asargent_no_longer_on_chrome, 2012/03/01 00:20:05]

Optional suggestion: the fact that the map owns the OffscreenTab* (and hence we
aren't leaking it at the end of this function) could be more clear here if
CreateOffscreenTab returned a const * or const &.

[jstritar, 2012/03/12 14:53:06]

Done.

+      parent_tab, url, width, height, extension_id());
+
+  // TODO(alexbost): Maybe the callback is called too soon. It should probably
+  // be called once we have navigated to the url.
+  if (has_callback()) {
+    result_.reset(offscreen_tab->CreateValue());
+    SendResponse(true);
+  }
+
+  return true;
+}
+
+GetOffscreenTabFunction::GetOffscreenTabFunction() {}
+GetOffscreenTabFunction::~GetOffscreenTabFunction() {}
+
+bool GetOffscreenTabFunction::RunImpl() {
+  int offscreen_tab_id;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &offscreen_tab_id));
+
+  OffscreenTab* offscreen_tab = NULL;
+  if (!GetMap()->GetOffscreenTab(
+          offscreen_tab_id, this, &offscreen_tab, &error_)) {
+    error_ = ExtensionErrorUtils::FormatErrorMessage(
+        keys::kOffscreenTabNotFoundError, base::IntToString(offscreen_tab_id));
+    return false;
+  }
+
+  result_.reset(offscreen_tab->CreateValue());
+  return true;
+}
+
+GetAllOffscreenTabFunction::GetAllOffscreenTabFunction() {}
+GetAllOffscreenTabFunction::~GetAllOffscreenTabFunction() {}
+
+bool GetAllOffscreenTabFunction::RunImpl() {
+  WebContents* web_contents = GetCurrentWebContents(this, &error_);
+  if (!web_contents)
+    return NULL;
+
+  ParentTab* parent_tab = GetMap()->GetParentTab(web_contents, extension_id());
+  ListValue* tab_list = new ListValue();
+  if (parent_tab) {
+    for (OffscreenTabs::const_iterator i = parent_tab->offscreen_tabs().begin();
+         i != parent_tab->offscreen_tabs().end(); ++i)
+      tab_list->Append((*i)->CreateValue());
+  }
+
+  result_.reset(tab_list);
+  return true;
+}
+
+RemoveOffscreenTabFunction::RemoveOffscreenTabFunction() {}
+RemoveOffscreenTabFunction::~RemoveOffscreenTabFunction() {}
+
+bool RemoveOffscreenTabFunction::RunImpl() {
+  int offscreen_tab_id;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &offscreen_tab_id));
+
+  OffscreenTab* offscreen_tab = NULL;
+  if (!GetMap()->GetOffscreenTab(
+          offscreen_tab_id, this, &offscreen_tab, &error_))
+    return false;
+
+  if (!GetMap()->RemoveOffscreenTab(offscreen_tab_id, this, &error_))
+    return false;
+
+  return true;
+}
+
+SendKeyboardEventOffscreenTabFunction::
+    SendKeyboardEventOffscreenTabFunction() {}
+SendKeyboardEventOffscreenTabFunction::
+    ~SendKeyboardEventOffscreenTabFunction() {}
+
+bool SendKeyboardEventOffscreenTabFunction::RunImpl() {
+  int offscreen_tab_id;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &offscreen_tab_id));
+
+  OffscreenTab* offscreen_tab = NULL;
+  if (!GetMap()->GetOffscreenTab(
+          offscreen_tab_id, this, &offscreen_tab, &error_))
+    return false;
+
+  // JavaScript KeyboardEvent.
+  DictionaryValue* js_keyboard_event = NULL;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &js_keyboard_event));
+
+  NativeWebKeyboardEvent keyboard_event;
+
+  std::string type;
+  if (js_keyboard_event->HasKey(keys::kEventTypeKey)) {
+    EXTENSION_FUNCTION_VALIDATE(
+        js_keyboard_event->GetString(keys::kEventTypeKey, &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 (js_keyboard_event->HasKey(keys::kKeyboardEventKeyCodeKey)) {
+    EXTENSION_FUNCTION_VALIDATE(js_keyboard_event->
+        GetInteger(keys::kKeyboardEventKeyCodeKey, &key_code));
+    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 (js_keyboard_event->HasKey(keys::kKeyboardEventCharCodeKey)) {
+      EXTENSION_FUNCTION_VALIDATE(js_keyboard_event->
+          GetInteger(keys::kKeyboardEventCharCodeKey, &char_code));
+      keyboard_event.text[0] = char_code;
+      keyboard_event.unmodifiedText[0] = char_code;
+    } else {
+      error_ = keys::kInvalidKeyboardEventObjectError;
+      return false;
+    }
+  }
+
+  EXTENSION_FUNCTION_VALIDATE(
+      CopyModifiers(js_keyboard_event, &keyboard_event));
+
+  // Forward the event.
+  offscreen_tab->web_contents()->GetRenderViewHost()->
+      ForwardKeyboardEvent(keyboard_event);
+
+  if (has_callback())
+    result_.reset(offscreen_tab->CreateValue());
+
+  SendResponse(true);

[asargent_no_longer_on_chrome, 2012/03/01 00:20:05]

Since this is a SyncExtensionFunction, you don't need to call SendResponse
manually right?

[jstritar, 2012/03/12 14:53:06]

Done.

+  return true;
+}
+
+SendMouseEventOffscreenTabFunction::SendMouseEventOffscreenTabFunction() {}
+SendMouseEventOffscreenTabFunction::~SendMouseEventOffscreenTabFunction() {}
+
+bool SendMouseEventOffscreenTabFunction::RunImpl() {
+  int offscreen_tab_id;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &offscreen_tab_id));
+
+  OffscreenTab* offscreen_tab = NULL;
+  if (!GetMap()->GetOffscreenTab(
+          offscreen_tab_id, this, &offscreen_tab, &error_))
+    return false;
+
+  // JavaScript MouseEvent.
+  DictionaryValue* js_mouse_event = NULL;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &js_mouse_event));
+
+  std::string type;
+  if (js_mouse_event->HasKey(keys::kEventTypeKey)) {
+    EXTENSION_FUNCTION_VALIDATE(
+        js_mouse_event->GetString(keys::kEventTypeKey, &type));
+  } else {
+    error_ = keys::kInvalidMouseEventObjectError;
+    return false;
+  }
+
+  if (type.compare(keys::kMouseEventTypeValueMousewheel) == 0) {
+    WebKit::WebMouseWheelEvent wheel_event;
+
+    wheel_event.type = WebInputEvent::MouseWheel;
+
+    if (js_mouse_event->HasKey(keys::kMouseEventWheelDeltaXKey) &&
+        js_mouse_event->HasKey(keys::kMouseEventWheelDeltaYKey)) {
+      int delta_x, delta_y;
+      EXTENSION_FUNCTION_VALIDATE(js_mouse_event->
+          GetInteger(keys::kMouseEventWheelDeltaXKey, &delta_x));
+      EXTENSION_FUNCTION_VALIDATE(js_mouse_event->
+          GetInteger(keys::kMouseEventWheelDeltaYKey, &delta_y));
+      wheel_event.deltaX = delta_x;
+      wheel_event.deltaY = delta_y;
+    } else {
+      error_ = keys::kInvalidMouseEventObjectError;
+      return false;
+    }
+
+    // Forward the event.
+    offscreen_tab->web_contents()->GetRenderViewHost()->
+        ForwardWheelEvent(wheel_event);
+  } else {
+    WebKit::WebMouseEvent mouse_event;
+
+    if (type.compare(keys::kMouseEventTypeValueMousedown) == 0 ||
+        type.compare(keys::kMouseEventTypeValueClick) == 0) {
+      mouse_event.type = WebInputEvent::MouseDown;
+    } else if (type.compare(keys::kMouseEventTypeValueMouseup) == 0) {
+      mouse_event.type = WebInputEvent::MouseUp;
+    } else if (type.compare(keys::kMouseEventTypeValueMousemove) == 0) {
+      mouse_event.type = WebInputEvent::MouseMove;
+    } else {
+      error_ = keys::kInvalidMouseEventObjectError;
+      return false;
+    }
+
+    int button;
+    if (js_mouse_event->HasKey(keys::kMouseEventButtonKey)) {
+      EXTENSION_FUNCTION_VALIDATE(
+          js_mouse_event->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;
+    }
+
+    EXTENSION_FUNCTION_VALIDATE(CopyModifiers(js_mouse_event, &mouse_event));
+
+    mouse_event.clickCount = 1;
+
+    // Forward the event.
+    offscreen_tab->web_contents()->GetRenderViewHost()->
+        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 = WebInputEvent::MouseUp;
+      offscreen_tab->web_contents()->GetRenderViewHost()->
+          ForwardMouseEvent(mouse_event);
+    }
+  }
+
+  if (has_callback())
+    result_.reset(offscreen_tab->CreateValue());
+
+  SendResponse(true);

[asargent_no_longer_on_chrome, 2012/03/01 00:20:05]

same thing here

[jstritar, 2012/03/12 14:53:06]

Done.

+  return true;
+}
+
+ToDataUrlOffscreenTabFunction::ToDataUrlOffscreenTabFunction() {}
+ToDataUrlOffscreenTabFunction::~ToDataUrlOffscreenTabFunction() {}
+
+bool ToDataUrlOffscreenTabFunction::GetTabToCapture(
+    WebContents** web_contents, TabContentsWrapper** wrapper) {
+  int offscreen_tab_id;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &offscreen_tab_id));
+
+  // 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).
+  OffscreenTab* offscreen_tab = NULL;
+  if (!GetMap()->GetOffscreenTab(
+          offscreen_tab_id, this, &offscreen_tab, &error_))
+    return false;
+
+  *web_contents = offscreen_tab->web_contents();
+  *wrapper = offscreen_tab->tab_contents();
+  return true;
+}
+
+UpdateOffscreenTabFunction::UpdateOffscreenTabFunction() {}
+UpdateOffscreenTabFunction::~UpdateOffscreenTabFunction() {}
+
+bool UpdateOffscreenTabFunction::RunImpl() {
+  int offscreen_tab_id;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &offscreen_tab_id));
+
+  OffscreenTab* offscreen_tab = NULL;
+  if (!GetMap()->GetOffscreenTab(
+          offscreen_tab_id, this, &offscreen_tab, &error_))
+    return false;
+
+  DictionaryValue* update_props;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &update_props));
+
+  web_contents_ = offscreen_tab->web_contents();
+  bool is_async = false;
+  if (!UpdateURLIfPresent(update_props, &is_async))
+    return false;
+
+  // Width and height
+  if (update_props->HasKey(tabs_keys::kWidthKey) ||
+      update_props->HasKey(tabs_keys::kHeightKey)) {
+    int width;
+    if (update_props->HasKey(tabs_keys::kWidthKey))
+      EXTENSION_FUNCTION_VALIDATE(
+          update_props->GetInteger(tabs_keys::kWidthKey, &width));
+    else
+      web_contents_->GetView()->GetContainerSize().width();
+
+    int height;
+    if (update_props->HasKey(tabs_keys::kHeightKey))
+      EXTENSION_FUNCTION_VALIDATE(
+          update_props->GetInteger(tabs_keys::kHeightKey, &height));
+    else
+      web_contents_->GetView()->GetContainerSize().height();
+
+    offscreen_tab->SetSize(width, height);
+  }
+
+  // Callback
+  if (has_callback())
+    result_.reset(offscreen_tab->CreateValue());
+
+  if (!is_async)
+    SendResponse(true);
+

[asargent_no_longer_on_chrome, 2012/03/01 00:20:05]

nit: Can you include a comment here about where SendResponse is called in the
async case? I assume somewhere in our UpdateTabFunction parent class. 

[jstritar, 2012/03/12 14:53:06]

Done.

+  return true;
+}