Merge lp:~chrisccoulson/oxide/web-frame-rework into lp:~oxide-developers/oxide/oxide.trunk

[Chris Coulson]

This refactors WebFrame and the content script message routing in both the browser and renderer to no longer use RenderView. The message routing is now done using RenderFrame, which fixes the problem that this code assumed all document frames live in the same process. This *should* future proof this functionality in preparation for http://www.chromium.org/developers/design-documents/site-isolation.

There's a couple of API changes too - WebFrame.childFrameChanged is replaced by WebView.frameAdded and WebView.frameRemoved, which is closer to what other libraries do.

WebView.rootFrameChanged is gone as well. This never really made sense, and makes less sense now the lifetime of our WebFrame is tied to the corresponding content::FrameTreeNode (in the same way that the lifetime of our WebView is pretty much tied to content::WebContents). Chromium never changes the root FrameTreeNode.

[lp:~chrisccoulson/oxide/web-frame-rework]

332. By Chris Coulson on 2014-01-29

Revert some renames - I didn't want to rename all instances of args to payload

333. By Chris Coulson on 2014-01-30

Don't build WebFrameAdapterPrivate in its own object file, as it's not necessary

334. By Chris Coulson on 2014-02-07

Merge from trunk

=== added file 'patches/add-frame-attached-to-web-contents-observer.patch'
--- patches/add-frame-attached-to-web-contents-observer.patch	1970-01-01 00:00:00 +0000
+++ patches/add-frame-attached-to-web-contents-observer.patch	2014-02-07 16:51:32 +0000
@@ -0,0 +1,177 @@
+# Description: Add WebContentsObserver::FrameAttached(), which is the opposite of
+#  the existing FrameDetached()
+# Author: Chris Coulson <[e-mail]>
+
+diff --git a/content/browser/frame_host/frame_tree.cc b/content/browser/frame_host/frame_tree.cc
+--- a/content/browser/frame_host/frame_tree.cc
++++ b/content/browser/frame_host/frame_tree.cc
+@@ -108,16 +108,21 @@ RenderFrameHostImpl* FrameTree::AddFrame
+     return NULL;
+ 
+   scoped_ptr<FrameTreeNode> node(new FrameTreeNode(
+       this, parent->navigator(), render_frame_delegate_, render_view_delegate_,
+       render_widget_delegate_, manager_delegate_, frame_id, frame_name));
+   FrameTreeNode* node_ptr = node.get();
+   // AddChild is what creates the RenderFrameHost.
+   parent->AddChild(node.Pass(), frame_routing_id);
++  if (!on_frame_added_.is_null()) {
++    on_frame_added_.Run(
++        node_ptr->current_frame_host()->render_view_host(),
++        parent_frame_id, frame_id);
++  }
+   return node_ptr->current_frame_host();
+ }
+ 
+ void FrameTree::RemoveFrame(RenderFrameHostImpl* render_frame_host,
+                             int64 parent_frame_id,
+                             int64 frame_id) {
+   // If switches::kSitePerProcess is not specified, then the FrameTree only
+   // contains a node for the root element. However, even in this case
+@@ -160,16 +165,21 @@ RenderFrameHostImpl* FrameTree::GetMainF
+   return root_->current_frame_host();
+ }
+ 
+ void FrameTree::SetFrameRemoveListener(
+     const base::Callback<void(RenderViewHostImpl*, int64)>& on_frame_removed) {
+   on_frame_removed_ = on_frame_removed;
+ }
+ 
++void FrameTree::SetFrameAddListener(
++    const base::Callback<void(RenderViewHostImpl*, int64, int64)>& on_frame_added) {
++  on_frame_added_ = on_frame_added;
++}
++
+ void FrameTree::ClearFrameRemoveListenerForTesting() {
+   on_frame_removed_.Reset();
+ }
+ 
+ RenderViewHostImpl* FrameTree::CreateRenderViewHostForMainFrame(
+     SiteInstance* site_instance,
+     int routing_id,
+     int main_frame_routing_id,
+diff --git a/content/browser/frame_host/frame_tree.h b/content/browser/frame_host/frame_tree.h
+--- a/content/browser/frame_host/frame_tree.h
++++ b/content/browser/frame_host/frame_tree.h
+@@ -96,16 +96,18 @@ class CONTENT_EXPORT FrameTree {
+   RenderFrameHostImpl* GetMainFrame() const;
+ 
+   // Allows a client to listen for frame removal.  The listener should expect
+   // to receive the RenderViewHostImpl containing the frame and the renderer-
+   // specific frame ID of the removed frame.
+   // TODO(creis): These parameters will later change to be the RenderFrameHost.
+   void SetFrameRemoveListener(
+       const base::Callback<void(RenderViewHostImpl*, int64)>& on_frame_removed);
++  void SetFrameAddListener(
++      const base::Callback<void(RenderViewHostImpl*, int64, int64)>& on_frame_added);
+ 
+   void ClearFrameRemoveListenerForTesting();
+ 
+   // Creates a RenderViewHost for a new main frame RenderFrameHost in the given
+   // |site_instance|.  The RenderViewHost will have its Shutdown method called
+   // when all of the RenderFrameHosts using it are deleted.
+   RenderViewHostImpl* CreateRenderViewHostForMainFrame(
+       SiteInstance* site_instance,
+@@ -147,15 +149,16 @@ class CONTENT_EXPORT FrameTree {
+   //
+   // Must be declared before |root_| so that it is deleted afterward.  Otherwise
+   // the map will be cleared before we delete the RenderFrameHosts in the tree.
+   RenderViewHostMap render_view_host_map_;
+ 
+   scoped_ptr<FrameTreeNode> root_;
+ 
+   base::Callback<void(RenderViewHostImpl*, int64)> on_frame_removed_;
++  base::Callback<void(RenderViewHostImpl*, int64, int64)> on_frame_added_;
+ 
+   DISALLOW_COPY_AND_ASSIGN(FrameTree);
+ };
+ 
+ }  // namespace content
+ 
+ #endif  // CONTENT_BROWSER_FRAME_HOST_FRAME_TREE_H_
+diff --git a/content/browser/web_contents/web_contents_impl.cc b/content/browser/web_contents/web_contents_impl.cc
+--- a/content/browser/web_contents/web_contents_impl.cc
++++ b/content/browser/web_contents/web_contents_impl.cc
+@@ -397,16 +397,19 @@ WebContentsImpl::WebContentsImpl(
+       render_view_message_source_(NULL),
+       fullscreen_widget_routing_id_(MSG_ROUTING_NONE),
+       is_subframe_(false) {
+   for (size_t i = 0; i < g_created_callbacks.Get().size(); i++)
+     g_created_callbacks.Get().at(i).Run(this);
+   frame_tree_.SetFrameRemoveListener(
+       base::Bind(&WebContentsImpl::OnFrameRemoved,
+                  base::Unretained(this)));
++  frame_tree_.SetFrameAddListener(
++      base::Bind(&WebContentsImpl::OnFrameAdded,
++                 base::Unretained(this)));
+ }
+ 
+ WebContentsImpl::~WebContentsImpl() {
+   is_being_destroyed_ = true;
+ 
+   ClearAllPowerSaveBlockers();
+ 
+   for (std::set<RenderWidgetHostImpl*>::iterator iter =
+@@ -3840,9 +3843,18 @@ gfx::Size WebContentsImpl::GetSizeForNew
+ 
+ void WebContentsImpl::OnFrameRemoved(
+     RenderViewHostImpl* render_view_host,
+     int64 frame_id) {
+    FOR_EACH_OBSERVER(WebContentsObserver, observers_,
+                      FrameDetached(render_view_host, frame_id));
+ }
+ 
++void WebContentsImpl::OnFrameAdded(
++    RenderViewHostImpl* render_view_host,
++    int64 parent_frame_id,
++    int64 frame_id) {
++  FOR_EACH_OBSERVER(WebContentsObserver, observers_,
++                    FrameAttached(render_view_host, parent_frame_id, frame_id));
++
++}
++
+ }  // namespace content
+diff --git a/content/browser/web_contents/web_contents_impl.h b/content/browser/web_contents/web_contents_impl.h
+--- a/content/browser/web_contents/web_contents_impl.h
++++ b/content/browser/web_contents/web_contents_impl.h
+@@ -825,16 +825,18 @@ class CONTENT_EXPORT WebContentsImpl
+ 
+   // Clear all PowerSaveBlockers, leave power_save_blocker_ empty.
+   void ClearAllPowerSaveBlockers();
+ 
+   // Helper function to invoke WebContentsDelegate::GetSizeForNewRenderView().
+   gfx::Size GetSizeForNewRenderView() const;
+ 
+   void OnFrameRemoved(RenderViewHostImpl* render_view_host, int64 frame_id);
++  void OnFrameAdded(RenderViewHostImpl* render_view_host,
++                    int64 parent_frame_id, int64 frame_id);
+ 
+   // Adds/removes a callback called on creation of each new WebContents.
+   // Deprecated, about to remove.
+   static void AddCreatedCallback(const CreatedCallback& callback);
+   static void RemoveCreatedCallback(const CreatedCallback& callback);
+ 
+   // Data for core operation ---------------------------------------------------
+ 
+diff --git a/content/public/browser/web_contents_observer.h b/content/public/browser/web_contents_observer.h
+--- a/content/public/browser/web_contents_observer.h
++++ b/content/public/browser/web_contents_observer.h
+@@ -229,16 +229,19 @@ class CONTENT_EXPORT WebContentsObserver
+                                    const GURL& url,
+                                    const Referrer& referrer,
+                                    WindowOpenDisposition disposition,
+                                    PageTransition transition,
+                                    int64 source_frame_id) {}
+ 
+   virtual void FrameDetached(RenderViewHost* render_view_host,
+                              int64 frame_id) {}
++  virtual void FrameAttached(RenderViewHost* render_view_host,
++                             int64 parent_frame_id,
++                             int64 frame_id) {}
+ 
+   // This method is invoked when the renderer has completed its first paint
+   // after a non-empty layout.
+   virtual void DidFirstVisuallyNonEmptyPaint(int32 page_id) {}
+ 
+   // These two methods correspond to the points in time when the spinner of the
+   // tab starts and stops spinning.
+   virtual void DidStartLoading(RenderViewHost* render_view_host) {}

=== removed file 'patches/add-frame-created-for-render-view.patch'
--- patches/add-frame-created-for-render-view.patch	2014-01-20 12:35:23 +0000
+++ patches/add-frame-created-for-render-view.patch	1970-01-01 00:00:00 +0000
@@ -1,73 +0,0 @@
-# Description: Make content::RenderViewObserver::FrameCreated() work correctly,
-#  so that we can track frames in the browser process
-# Author: Chris Coulson <[e-mail]>
-
-diff --git a/content/renderer/render_frame_impl.cc b/content/renderer/render_frame_impl.cc
---- a/content/renderer/render_frame_impl.cc
-+++ b/content/renderer/render_frame_impl.cc
-@@ -587,16 +587,18 @@ blink::WebFrame* RenderFrameImpl::create
-   // TODO(nasko): Over-conservative check for debugging.
-   CHECK(child_render_frame);
-   blink::WebFrame* web_frame = WebFrame::create(child_render_frame,
-                                                 child_frame_identifier);
-   // TODO(nasko): Over-conservative check for debugging.
-   CHECK(web_frame);
-   child_render_frame->SetWebFrame(web_frame);
- 
-+  render_view_->FrameCreated(parent, web_frame);
-+
-   return web_frame;
- }
- 
- void RenderFrameImpl::didDisownOpener(blink::WebFrame* frame) {
-   render_view_->didDisownOpener(frame);
- }
- 
- void RenderFrameImpl::frameDetached(blink::WebFrame* frame) {
-diff --git a/content/renderer/render_view_impl.cc b/content/renderer/render_view_impl.cc
---- a/content/renderer/render_view_impl.cc
-+++ b/content/renderer/render_view_impl.cc
-@@ -4297,16 +4297,21 @@ void RenderViewImpl::DidPause(blink::Web
-                                          player->hasAudio(),
-                                          false));
- }
- 
- void RenderViewImpl::PlayerGone(blink::WebMediaPlayer* player) {
-   DidPause(player);
- }
- 
-+void RenderViewImpl::FrameCreated(blink::WebFrame* parent,
-+                                  blink::WebFrame* frame) {
-+  FOR_EACH_OBSERVER(RenderViewObserver, observers_, FrameCreated(parent, frame));
-+}
-+
- void RenderViewImpl::SyncNavigationState() {
-   if (!webview())
-     return;
- 
-   const WebHistoryItem& item = webview()->mainFrame()->currentHistoryItem();
-   SendUpdateState(item);
- }
- 
-diff --git a/content/renderer/render_view_impl.h b/content/renderer/render_view_impl.h
---- a/content/renderer/render_view_impl.h
-+++ b/content/renderer/render_view_impl.h
-@@ -680,16 +680,18 @@ class CONTENT_EXPORT RenderViewImpl
-   // appropriate section, add it there. If not, there are some random functions
-   // nearer to the top you can add it to.
- 
-   // Cannot use std::set unfortunately since linked_ptr<> does not support
-   // operator<.
-   typedef std::vector<linked_ptr<ImageResourceFetcher> >
-       ImageResourceFetcherList;
- 
-+  void FrameCreated(blink::WebFrame* parent, blink::WebFrame* frame);
-+
-  protected:
-   // RenderWidget overrides:
-   virtual void Close() OVERRIDE;
-   virtual void OnResize(const ViewMsg_Resize_Params& params) OVERRIDE;
-   virtual void DidInitiatePaint() OVERRIDE;
-   virtual void DidFlushPaint() OVERRIDE;
-   virtual PepperPluginInstanceImpl* GetBitmapForOptimizedPluginPaint(
-       const gfx::Rect& paint_bounds,

=== modified file 'patches/series'
--- patches/series	2014-02-07 16:15:16 +0000
+++ patches/series	2014-02-07 16:51:32 +0000
@@ -3,7 +3,6 @@
 gyp-support-library-version.patch
 support-native-popup-menus.patch
 add-oxide-messages.patch
-add-frame-created-for-render-view.patch
 add-oxide-resources.patch
 share-gl-resources-with-embedder.patch
 arm-icu.patch
@@ -12,3 +11,4 @@
 dont-depend-on-gtk.patch
 arm-neon.patch
 dont-use-egl-create-context-robustness.patch
+add-frame-attached-to-web-contents-observer.patch

=== added directory 'qt/core/api/internal'
=== added file 'qt/core/api/internal/oxideqwebpreferences_p.cc'
--- qt/core/api/internal/oxideqwebpreferences_p.cc	1970-01-01 00:00:00 +0000
+++ qt/core/api/internal/oxideqwebpreferences_p.cc	2014-02-07 16:51:32 +0000
@@ -0,0 +1,53 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2013 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#include "../oxideqwebpreferences_p.h"
+#include "../oxideqwebpreferences.h"
+
+#include "qt/core/glue/oxide_qt_web_view_adapter.h"
+
+OxideQWebPreferencesPrivate::OxideQWebPreferencesPrivate() :
+    in_destructor_(false) {}
+
+OxideQWebPreferencesPrivate::~OxideQWebPreferencesPrivate() {
+  in_destructor_ = true;
+
+  for (std::set<oxide::qt::WebViewAdapter *>::const_iterator it = views_.begin();
+       it != views_.end(); ++it) {
+    oxide::qt::WebViewAdapter* view = *it;
+    view->NotifyWebPreferencesDestroyed();
+  }
+}
+
+void OxideQWebPreferencesPrivate::AddWebView(oxide::qt::WebViewAdapter* view) {
+  Q_ASSERT(!in_destructor_);
+  views_.insert(view);
+}
+
+void OxideQWebPreferencesPrivate::RemoveWebView(
+    oxide::qt::WebViewAdapter* view) {
+  if (in_destructor_) {
+    return;
+  }
+
+  views_.erase(view);
+}
+
+// static
+OxideQWebPreferencesPrivate* OxideQWebPreferencesPrivate::get(OxideQWebPreferences* q) {
+  return q->d_func();
+}

=== added file 'qt/core/api/oxideqwebpreferences.cc'
--- qt/core/api/oxideqwebpreferences.cc	1970-01-01 00:00:00 +0000
+++ qt/core/api/oxideqwebpreferences.cc	2014-02-07 16:51:32 +0000
@@ -0,0 +1,197 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2013 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#include "oxideqwebpreferences.h"
+#include "oxideqwebpreferences_p.h"
+
+OxideQWebPreferences::~OxideQWebPreferences() {}
+
+OxideQWebPreferences::OxideQWebPreferences(QObject* parent) :
+    QObject(parent),
+    d_ptr(new OxideQWebPreferencesPrivate()) {}
+
+QString OxideQWebPreferences::standardFontFamily() const {
+  Q_D(const OxideQWebPreferences);
+  return QString::fromStdString(d->preferences().StandardFontFamily());
+}
+
+void OxideQWebPreferences::setStandardFontFamily(const QString& font) {
+  Q_D(OxideQWebPreferences);
+
+  if (font == standardFontFamily()) {
+    return;
+  }
+
+  d->preferences().SetStandardFontFamily(font.toStdString());
+  Q_EMIT standardFontFamilyChanged();
+}
+
+QString OxideQWebPreferences::fixedFontFamily() const {
+  Q_D(const OxideQWebPreferences);
+  return QString::fromStdString(d->preferences().FixedFontFamily());
+}
+
+void OxideQWebPreferences::setFixedFontFamily(const QString& font) {
+  Q_D(OxideQWebPreferences);
+
+  if (font == fixedFontFamily()) {
+    return;
+  }
+
+  d->preferences().SetFixedFontFamily(font.toStdString());
+  Q_EMIT fixedFontFamilyChanged();
+}
+
+QString OxideQWebPreferences::serifFontFamily() const {
+  Q_D(const OxideQWebPreferences);
+  return QString::fromStdString(d->preferences().SerifFontFamily());
+}
+
+void OxideQWebPreferences::setSerifFontFamily(const QString& font) {
+  Q_D(OxideQWebPreferences);
+
+  if (font == serifFontFamily()) {
+    return;
+  }
+
+  d->preferences().SetSerifFontFamily(font.toStdString());
+  Q_EMIT serifFontFamilyChanged();
+}
+
+QString OxideQWebPreferences::sansSerifFontFamily() const {
+  Q_D(const OxideQWebPreferences);
+  return QString::fromStdString(d->preferences().SansSerifFontFamily());
+}
+
+void OxideQWebPreferences::setSansSerifFontFamily(const QString& font) {
+  Q_D(OxideQWebPreferences);
+
+  if (font == sansSerifFontFamily()) {
+    return;
+  }
+
+  d->preferences().SetSansSerifFontFamily(font.toStdString());
+  Q_EMIT sansSerifFontFamilyChanged();
+}
+
+QString OxideQWebPreferences::defaultEncoding() const {
+  Q_D(const OxideQWebPreferences);
+  return QString::fromStdString(d->preferences().default_encoding());
+}
+
+void OxideQWebPreferences::setDefaultEncoding(const QString& encoding) {
+  Q_D(OxideQWebPreferences);
+
+  if (encoding == defaultEncoding()) {
+    return;
+  }
+
+  d->preferences().SetDefaultEncoding(encoding.toStdString());
+  Q_EMIT defaultEncodingChanged();
+}
+
+unsigned OxideQWebPreferences::defaultFontSize() const {
+  Q_D(const OxideQWebPreferences);
+  return d->preferences().default_font_size();
+}
+
+void OxideQWebPreferences::setDefaultFontSize(unsigned size) {
+  Q_D(OxideQWebPreferences);
+
+  if (size == defaultFontSize()) {
+    return;
+  }
+
+  d->preferences().SetDefaultFontSize(size);
+  Q_EMIT defaultFontSizeChanged();
+}
+
+unsigned OxideQWebPreferences::defaultFixedFontSize() const {
+  Q_D(const OxideQWebPreferences);
+  return d->preferences().default_fixed_font_size();
+}
+
+void OxideQWebPreferences::setDefaultFixedFontSize(unsigned size) {
+  Q_D(OxideQWebPreferences);
+
+  if (size == defaultFixedFontSize()) {
+    return;
+  }
+
+  d->preferences().SetDefaultFixedFontSize(size);
+  Q_EMIT defaultFixedFontSizeChanged();
+}
+
+unsigned OxideQWebPreferences::minimumFontSize() const {
+  Q_D(const OxideQWebPreferences);
+  return d->preferences().minimum_font_size();
+}
+
+void OxideQWebPreferences::setMinimumFontSize(unsigned size) {
+  Q_D(OxideQWebPreferences);
+
+  if (size == minimumFontSize()) {
+    return;
+  }
+
+  d->preferences().SetMinimumFontSize(size);
+  Q_EMIT minimumFontSizeChanged();
+}
+
+#define BOOLEAN_PREF_IMPL(getter, setter, attr) \
+  bool OxideQWebPreferences::getter() const { \
+    Q_D(const OxideQWebPreferences); \
+    return d->preferences().TestAttribute( \
+        oxide::WebPreferences::ATTR_##attr); \
+  } \
+\
+  void OxideQWebPreferences::setter(bool val) { \
+    Q_D(OxideQWebPreferences); \
+    if (val == getter()) { \
+      return; \
+    } \
+    d->preferences().SetAttribute( \
+        oxide::WebPreferences::ATTR_##attr, val); \
+    Q_EMIT getter##Changed(); \
+  }
+
+BOOLEAN_PREF_IMPL(remoteFontsEnabled, setRemoteFontsEnabled, REMOTE_FONTS_ENABLED)
+BOOLEAN_PREF_IMPL(javascriptEnabled, setJavascriptEnabled, JAVASCRIPT_ENABLED)
+BOOLEAN_PREF_IMPL(webSecurityEnabled, setWebSecurityEnabled, WEB_SECURITY_ENABLED)
+BOOLEAN_PREF_IMPL(popupBlockerEnabled, setPopupBlockerEnabled, POPUP_BLOCKER_ENABLED)
+BOOLEAN_PREF_IMPL(allowScriptsToCloseWindows, setAllowScriptsToCloseWindows, ALLOW_SCRIPTS_TO_CLOSE_WINDOWS)
+BOOLEAN_PREF_IMPL(javascriptCanAccessClipboard, setJavascriptCanAccessClipboard, JAVASCRIPT_CAN_ACCESS_CLIPBOARD)
+BOOLEAN_PREF_IMPL(hyperlinkAuditingEnabled, setHyperlinkAuditingEnabled, HYPERLINK_AUDITING_ENABLED)
+BOOLEAN_PREF_IMPL(allowUniversalAccessFromFileUrls, setAllowUniversalAccessFromFileUrls, ALLOW_UNIVERSAL_ACCESS_FROM_FILE_URLS)
+BOOLEAN_PREF_IMPL(allowFileAccessFromFileUrls, setAllowFileAccessFromFileUrls, ALLOW_FILE_ACCESS_FROM_FILE_URLS)
+BOOLEAN_PREF_IMPL(canDisplayInsecureContent, setCanDisplayInsecureContent, CAN_DISPLAY_INSECURE_CONTENT)
+BOOLEAN_PREF_IMPL(canRunInsecureContent, setCanRunInsecureContent, CAN_RUN_INSECURE_CONTENT)
+BOOLEAN_PREF_IMPL(passwordEchoEnabled, setPasswordEchoEnabled, PASSWORD_ECHO_ENABLED)
+BOOLEAN_PREF_IMPL(loadsImagesAutomatically, setLoadsImagesAutomatically, LOADS_IMAGES_AUTOMATICALLY)
+BOOLEAN_PREF_IMPL(shrinksStandaloneImagesToFit, setShrinksStandaloneImagesToFit, SHRINKS_STANDALONE_IMAGES_TO_FIT)
+BOOLEAN_PREF_IMPL(textAreasAreResizable, setTextAreasAreResizable, TEXT_AREAS_ARE_RESIZABLE)
+BOOLEAN_PREF_IMPL(localStorageEnabled, setLocalStorageEnabled, LOCAL_STORAGE_ENABLED)
+BOOLEAN_PREF_IMPL(databasesEnabled, setDatabasesEnabled, DATABASES_ENABLED)
+BOOLEAN_PREF_IMPL(appCacheEnabled, setAppCacheEnabled, APP_CACHE_ENABLED)
+BOOLEAN_PREF_IMPL(fullscreenEnabled, setFullscreenEnabled, FULLSCREEN_ENABLED)
+BOOLEAN_PREF_IMPL(tabsToLinks, setTabsToLinks, TABS_TO_LINKS)
+BOOLEAN_PREF_IMPL(caretBrowsingEnabled, setCaretBrowsingEnabled, CARET_BROWSING_ENABLED)
+BOOLEAN_PREF_IMPL(acceleratedCompositingEnabled, setAcceleratedCompositingEnabled, ACCELERATED_COMPOSITING_ENABLED)
+BOOLEAN_PREF_IMPL(smoothScrollingEnabled, setSmoothScrollingEnabled, SMOOTH_SCROLLING_ENABLED)
+BOOLEAN_PREF_IMPL(touchEnabled, setTouchEnabled, TOUCH_ENABLED)
+BOOLEAN_PREF_IMPL(supportsMultipleWindows, setSupportsMultipleWindows, SUPPORTS_MULTIPLE_WINDOWS)
+BOOLEAN_PREF_IMPL(viewportEnabled, setViewportEnabled, VIEWPORT_ENABLED)

=== added file 'qt/core/api/oxideqwebpreferences.h'
--- qt/core/api/oxideqwebpreferences.h	1970-01-01 00:00:00 +0000
+++ qt/core/api/oxideqwebpreferences.h	2014-02-07 16:51:32 +0000
@@ -0,0 +1,212 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2013 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#ifndef OXIDE_Q_WEB_PREFERENCES
+#define OXIDE_Q_WEB_PREFERENCES
+
+#include <QObject>
+#include <QScopedPointer>
+#include <QString>
+#include <QtGlobal>
+
+class OxideQWebPreferencesPrivate;
+
+class Q_DECL_EXPORT OxideQWebPreferences : public QObject {
+  Q_OBJECT
+
+  Q_PROPERTY(QString standardFontFamily READ standardFontFamily WRITE setStandardFontFamily NOTIFY standardFontFamilyChanged)
+  Q_PROPERTY(QString fixedFontFamily READ fixedFontFamily WRITE setFixedFontFamily NOTIFY fixedFontFamilyChanged)
+  Q_PROPERTY(QString serifFontFamily READ serifFontFamily WRITE setSerifFontFamily NOTIFY serifFontFamilyChanged)
+  Q_PROPERTY(QString sanSerifFontFamily READ sansSerifFontFamily WRITE setSansSerifFontFamily NOTIFY sansSerifFontFamilyChanged)
+
+  Q_PROPERTY(bool remoteFontsEnabled READ remoteFontsEnabled WRITE setRemoteFontsEnabled NOTIFY remoteFontsEnabledChanged)
+
+  Q_PROPERTY(QString defaultEncoding READ defaultEncoding WRITE setDefaultEncoding NOTIFY defaultEncodingChanged)
+
+  Q_PROPERTY(unsigned defaultFontSize READ defaultFontSize WRITE setDefaultFontSize NOTIFY defaultFontSizeChanged)
+  Q_PROPERTY(unsigned defaultFixedFontSize READ defaultFixedFontSize WRITE setDefaultFixedFontSize NOTIFY defaultFixedFontSizeChanged)
+  Q_PROPERTY(unsigned minimumFontSize READ minimumFontSize WRITE setMinimumFontSize NOTIFY minimumFontSizeChanged)
+
+  Q_PROPERTY(bool javascriptEnabled READ javascriptEnabled WRITE setJavascriptEnabled NOTIFY javascriptEnabledChanged)
+  Q_PROPERTY(bool webSecurityEnabled READ webSecurityEnabled WRITE setWebSecurityEnabled NOTIFY webSecurityEnabledChanged)
+  Q_PROPERTY(bool popupBlockerEnabled READ popupBlockerEnabled WRITE setPopupBlockerEnabled NOTIFY popupBlockerEnabledChanged)
+  Q_PROPERTY(bool allowScriptsToCloseWindows READ allowScriptsToCloseWindows WRITE setAllowScriptsToCloseWindows NOTIFY allowScriptsToCloseWindowsChanged)
+  Q_PROPERTY(bool javascriptCanAccessClipboard READ javascriptCanAccessClipboard WRITE setJavascriptCanAccessClipboard NOTIFY javascriptCanAccessClipboardChanged)
+
+  Q_PROPERTY(bool hyperlinkAuditingEnabled READ hyperlinkAuditingEnabled WRITE setHyperlinkAuditingEnabled NOTIFY hyperlinkAuditingEnabledChanged)
+  Q_PROPERTY(bool allowUniversalAccessFromFileUrls READ allowUniversalAccessFromFileUrls WRITE setAllowUniversalAccessFromFileUrls NOTIFY allowUniversalAccessFromFileUrlsChanged)
+  Q_PROPERTY(bool allowFileAccessFromFileUrls READ allowFileAccessFromFileUrls WRITE setAllowFileAccessFromFileUrls NOTIFY allowFileAccessFromFileUrlsChanged)
+  Q_PROPERTY(bool canDisplayInsecureContent READ canDisplayInsecureContent WRITE setCanDisplayInsecureContent NOTIFY canDisplayInsecureContentChanged)
+  Q_PROPERTY(bool canRunInsecureContent READ canRunInsecureContent WRITE setCanRunInsecureContent NOTIFY canRunInsecureContentChanged)
+  Q_PROPERTY(bool passwordEchoEnabled READ passwordEchoEnabled WRITE setPasswordEchoEnabled NOTIFY passwordEchoEnabledChanged)
+
+  Q_PROPERTY(bool loadsImagesAutomatically READ loadsImagesAutomatically WRITE setLoadsImagesAutomatically NOTIFY loadsImagesAutomaticallyChanged)
+  Q_PROPERTY(bool shrinksStandaloneImagesToFit READ shrinksStandaloneImagesToFit WRITE setShrinksStandaloneImagesToFit NOTIFY shrinksStandaloneImagesToFitChanged)
+
+  Q_PROPERTY(bool textAreasAreResizable READ textAreasAreResizable WRITE setTextAreasAreResizable NOTIFY textAreasAreResizableChanged)
+  
+  Q_PROPERTY(bool localStorageEnabled READ localStorageEnabled WRITE setLocalStorageEnabled NOTIFY localStorageEnabledChanged)
+  Q_PROPERTY(bool databasesEnabled READ databasesEnabled WRITE setDatabasesEnabled NOTIFY databasesEnabledChanged)
+  Q_PROPERTY(bool appCacheEnabled READ appCacheEnabled WRITE setAppCacheEnabled NOTIFY appCacheEnabledChanged)
+  Q_PROPERTY(bool fullscreenEnabled READ fullscreenEnabled WRITE setFullscreenEnabled NOTIFY fullscreenEnabledChanged)
+
+  Q_PROPERTY(bool tabsToLinks READ tabsToLinks WRITE setTabsToLinks NOTIFY tabsToLinksChanged)
+  Q_PROPERTY(bool caretBrowsingEnabled READ caretBrowsingEnabled WRITE setCaretBrowsingEnabled NOTIFY caretBrowsingEnabledChanged)
+
+  Q_PROPERTY(bool acceleratedCompositingEnabled READ acceleratedCompositingEnabled WRITE setAcceleratedCompositingEnabled NOTIFY acceleratedCompositingEnabledChanged)
+  Q_PROPERTY(bool smoothScrollingEnabled READ smoothScrollingEnabled WRITE setSmoothScrollingEnabled NOTIFY smoothScrollingEnabledChanged)
+  Q_PROPERTY(bool touchEnabled READ touchEnabled WRITE setTouchEnabled NOTIFY touchEnabledChanged)
+  Q_PROPERTY(bool supportsMultipleWindows READ supportsMultipleWindows WRITE setSupportsMultipleWindows NOTIFY supportsMultipleWindowsChanged)
+  Q_PROPERTY(bool viewportEnabled READ viewportEnabled WRITE setViewportEnabled NOTIFY viewportEnabledChanged)
+
+  Q_DECLARE_PRIVATE(OxideQWebPreferences)
+  Q_DISABLE_COPY(OxideQWebPreferences)
+
+ public:
+  virtual ~OxideQWebPreferences();
+  OxideQWebPreferences(QObject* parent = NULL);
+
+  QString standardFontFamily() const;
+  void setStandardFontFamily(const QString& font);
+  QString fixedFontFamily() const;
+  void setFixedFontFamily(const QString& font);
+  QString serifFontFamily() const;
+  void setSerifFontFamily(const QString& font);
+  QString sansSerifFontFamily() const;
+  void setSansSerifFontFamily(const QString& font);
+
+  bool remoteFontsEnabled() const;
+  void setRemoteFontsEnabled(bool enabled);
+
+  QString defaultEncoding() const;
+  void setDefaultEncoding(const QString& encoding);
+
+  unsigned defaultFontSize() const;
+  void setDefaultFontSize(unsigned size);
+  unsigned defaultFixedFontSize() const;
+  void setDefaultFixedFontSize(unsigned size);
+  unsigned minimumFontSize() const;
+  void setMinimumFontSize(unsigned size);
+
+  bool javascriptEnabled() const;
+  void setJavascriptEnabled(bool enabled);
+  bool webSecurityEnabled() const;
+  void setWebSecurityEnabled(bool enabled);
+  bool popupBlockerEnabled() const;
+  void setPopupBlockerEnabled(bool enabled);
+  bool allowScriptsToCloseWindows() const;
+  void setAllowScriptsToCloseWindows(bool allow);
+  bool javascriptCanAccessClipboard() const;
+  void setJavascriptCanAccessClipboard(bool allow);
+
+  bool hyperlinkAuditingEnabled() const;
+  void setHyperlinkAuditingEnabled(bool enabled);
+  bool allowUniversalAccessFromFileUrls() const;
+  void setAllowUniversalAccessFromFileUrls(bool allow);
+  bool allowFileAccessFromFileUrls() const;
+  void setAllowFileAccessFromFileUrls(bool allow);
+  bool canDisplayInsecureContent() const;
+  void setCanDisplayInsecureContent(bool allow);
+  bool canRunInsecureContent() const;
+  void setCanRunInsecureContent(bool allow);
+  bool passwordEchoEnabled() const;
+  void setPasswordEchoEnabled(bool enabled);
+
+  bool loadsImagesAutomatically() const;
+  void setLoadsImagesAutomatically(bool enabled);
+  bool shrinksStandaloneImagesToFit() const;
+  void setShrinksStandaloneImagesToFit(bool enabled);
+
+  bool textAreasAreResizable() const;
+  void setTextAreasAreResizable(bool enabled);
+
+  bool localStorageEnabled() const;
+  void setLocalStorageEnabled(bool enabled);
+  bool databasesEnabled() const;
+  void setDatabasesEnabled(bool enabled);
+  bool appCacheEnabled() const;
+  void setAppCacheEnabled(bool enabled);
+  bool fullscreenEnabled() const;
+  void setFullscreenEnabled(bool enabled);
+
+  bool tabsToLinks() const;
+  void setTabsToLinks(bool enabled);
+  bool caretBrowsingEnabled() const;
+  void setCaretBrowsingEnabled(bool enabled);
+
+  bool acceleratedCompositingEnabled() const;
+  void setAcceleratedCompositingEnabled(bool enabled);
+  bool smoothScrollingEnabled() const;
+  void setSmoothScrollingEnabled(bool enabled);
+  bool touchEnabled() const;
+  void setTouchEnabled(bool enabled);
+  bool supportsMultipleWindows() const;
+  void setSupportsMultipleWindows(bool enabled);
+  bool viewportEnabled() const;
+  void setViewportEnabled(bool enabled);
+
+ Q_SIGNALS:
+  void standardFontFamilyChanged();
+  void fixedFontFamilyChanged();
+  void serifFontFamilyChanged();
+  void sansSerifFontFamilyChanged();
+
+  void remoteFontsEnabledChanged();
+
+  void defaultEncodingChanged();
+
+  void defaultFontSizeChanged();
+  void defaultFixedFontSizeChanged();
+  void minimumFontSizeChanged();
+
+  void javascriptEnabledChanged();
+  void webSecurityEnabledChanged();
+  void popupBlockerEnabledChanged();
+  void allowScriptsToCloseWindowsChanged();
+  void javascriptCanAccessClipboardChanged();
+
+  void hyperlinkAuditingEnabledChanged();
+  void allowUniversalAccessFromFileUrlsChanged();
+  void allowFileAccessFromFileUrlsChanged();
+  void canDisplayInsecureContentChanged();
+  void canRunInsecureContentChanged();
+  void passwordEchoEnabledChanged();
+
+  void loadsImagesAutomaticallyChanged();
+  void shrinksStandaloneImagesToFitChanged();
+
+  void textAreasAreResizableChanged();
+
+  void localStorageEnabledChanged();
+  void databasesEnabledChanged();
+  void appCacheEnabledChanged();
+  void fullscreenEnabledChanged();
+
+  void tabsToLinksChanged();
+  void caretBrowsingEnabledChanged();
+
+  void acceleratedCompositingEnabledChanged();
+  void smoothScrollingEnabledChanged();
+  void touchEnabledChanged();
+  void supportsMultipleWindowsChanged();
+  void viewportEnabledChanged();
+
+ private:
+  QScopedPointer<OxideQWebPreferencesPrivate> d_ptr;
+};
+
+#endif // OXIDE_Q_WEB_PREFERENCES

=== added file 'qt/core/api/oxideqwebpreferences_p.h'
--- qt/core/api/oxideqwebpreferences_p.h	1970-01-01 00:00:00 +0000
+++ qt/core/api/oxideqwebpreferences_p.h	2014-02-07 16:51:32 +0000
@@ -0,0 +1,59 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2013 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#ifndef _OXIDE_QT_CORE_API_WEB_PREFERENCES_P_H_
+#define _OXIDE_QT_CORE_API_WEB_PREFERENCES_P_H_
+
+#include <set>
+#include <QtGlobal>
+
+#include "qt/core/browser/oxide_qt_web_preferences.h"
+
+class OxideQWebPreferences;
+
+namespace oxide {
+namespace qt {
+class WebViewAdapter;
+} // namespace qt
+} // namespace oxide
+
+class OxideQWebPreferencesPrivate Q_DECL_FINAL {
+ public:
+  OxideQWebPreferencesPrivate();
+  ~OxideQWebPreferencesPrivate();
+
+  oxide::qt::WebPreferences& preferences() {
+    return preferences_;
+  }
+  const oxide::qt::WebPreferences& preferences() const {
+    return preferences_;
+  }
+
+  bool in_destructor() const { return in_destructor_; }
+
+  void AddWebView(oxide::qt::WebViewAdapter* view);
+  void RemoveWebView(oxide::qt::WebViewAdapter* view);
+
+  static OxideQWebPreferencesPrivate* get(OxideQWebPreferences* q);
+
+ private:
+  oxide::qt::WebPreferences preferences_;
+  std::set<oxide::qt::WebViewAdapter *> views_;
+  bool in_destructor_;
+};
+
+#endif // _OXIDE_QT_CORE_API_WEB_PREFERENCES_P_H_

=== modified file 'qt/core/browser/oxide_qt_content_browser_client.cc'
--- qt/core/browser/oxide_qt_content_browser_client.cc	2014-02-03 13:41:53 +0000
+++ qt/core/browser/oxide_qt_content_browser_client.cc	2014-02-07 16:51:32 +0000
@@ -21,6 +21,7 @@
 #include <QString>
 #include <QtGui/qpa/qplatformnativeinterface.h>
 
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 
 #include "shared/gl/oxide_shared_gl_context.h"
@@ -29,12 +30,16 @@
 
 #include "oxide_qt_message_pump.h"
 #include "oxide_qt_render_widget_host_view.h"
+#include "oxide_qt_web_preferences.h"
 
 namespace oxide {
 namespace qt {
 
 namespace {
 
+base::LazyInstance<WebPreferences> g_default_web_preferences =
+    LAZY_INSTANCE_INITIALIZER;
+
 class SharedGLContext : public oxide::SharedGLContext {
  public:
   SharedGLContext(QOpenGLContext* context, oxide::GLShareGroup* share_group) :
@@ -120,5 +125,9 @@
       QGuiApplication::primaryScreen(), result);
 }
 
+oxide::WebPreferences* ContentBrowserClient::GetDefaultWebPreferences() {
+  return g_default_web_preferences.Pointer();
+}
+
 } // namespace qt
 } // namespace oxide

=== modified file 'qt/core/browser/oxide_qt_content_browser_client.h'
--- qt/core/browser/oxide_qt_content_browser_client.h	2014-01-13 22:06:04 +0000
+++ qt/core/browser/oxide_qt_content_browser_client.h	2014-02-07 16:51:32 +0000
@@ -42,6 +42,8 @@
 
   void GetDefaultScreenInfo(blink::WebScreenInfo* result) FINAL;
 
+  oxide::WebPreferences* GetDefaultWebPreferences() FINAL;
+
  private:
   // Limit default constructor access to the lazy instance initializer
   friend struct base::DefaultLazyInstanceTraits<ContentBrowserClient>;

=== modified file 'qt/core/browser/oxide_qt_web_frame.cc'
--- qt/core/browser/oxide_qt_web_frame.cc	2013-10-29 01:06:23 +0000
+++ qt/core/browser/oxide_qt_web_frame.cc	2014-02-07 16:51:32 +0000
@@ -22,55 +22,57 @@
 #include "base/logging.h"
 
 #include "qt/core/glue/oxide_qt_web_frame_adapter.h"
+#include "qt/core/glue/oxide_qt_web_frame_adapter_p.h"
 #include "qt/core/glue/private/oxide_qt_message_handler_adapter_p.h"
 #include "qt/core/glue/private/oxide_qt_outgoing_message_request_adapter_p.h"
-#include "qt/core/glue/private/oxide_qt_web_frame_adapter_p.h"
 
 namespace oxide {
 namespace qt {
 
 WebFrame::~WebFrame() {
-  delete adapterToQObject(adapter);
-  DCHECK(!adapter);
+  delete adapterToQObject(adapter_);
 }
 
 void WebFrame::OnChildAdded(oxide::WebFrame* child) {
-  adapterToQObject(static_cast<WebFrame *>(child)->adapter)->setParent(
-      adapterToQObject(adapter));
+  adapterToQObject(static_cast<WebFrame *>(child)->adapter())->setParent(
+      adapterToQObject(adapter_));
 }
 
 void WebFrame::OnChildRemoved(oxide::WebFrame* child) {
-  adapterToQObject(static_cast<WebFrame *>(child)->adapter)->setParent(NULL);
+  adapterToQObject(static_cast<WebFrame *>(child)->adapter())->setParent(NULL);
 }
 
 void WebFrame::OnURLChanged() {
-  adapter->URLChanged();
+  adapter_->URLChanged();
 }
 
-WebFrame::WebFrame(WebFrameAdapter* adapter) :
-    adapter(adapter) {
+WebFrame::WebFrame(WebFrameAdapter* adapter,
+                   content::FrameTreeNode* node,
+                   oxide::WebView* view) :
+    oxide::WebFrame(node, view),
+    adapter_(adapter) {
   WebFrameAdapterPrivate::get(adapter)->owner = this;
 }
 
 size_t WebFrame::GetMessageHandlerCount() const {
-  return adapter->message_handlers().size();
+  return adapter_->message_handlers().size();
 }
 
 oxide::MessageHandler* WebFrame::GetMessageHandlerAt(
     size_t index) const {
-  MessageHandlerAdapter* handler = adapter->message_handlers().at(index);
+  MessageHandlerAdapter* handler = adapter_->message_handlers().at(index);
   return &MessageHandlerAdapterPrivate::get(handler)->handler();
 }
 
 size_t WebFrame::GetOutgoingMessageRequestCount() const {
   return WebFrameAdapterPrivate::get(
-      adapter)->outgoing_message_requests().size();
+      adapter_)->outgoing_message_requests().size();
 }
 
 oxide::OutgoingMessageRequest* WebFrame::GetOutgoingMessageRequestAt(
     size_t index) const {
   OutgoingMessageRequestAdapter* req =
-      WebFrameAdapterPrivate::get(adapter)->outgoing_message_requests().at(index);
+      WebFrameAdapterPrivate::get(adapter_)->outgoing_message_requests().at(index);
   return &OutgoingMessageRequestAdapterPrivate::get(req)->request();
 }
 

=== modified file 'qt/core/browser/oxide_qt_web_frame.h'
--- qt/core/browser/oxide_qt_web_frame.h	2013-10-28 15:56:40 +0000
+++ qt/core/browser/oxide_qt_web_frame.h	2014-02-07 16:51:32 +0000
@@ -30,7 +30,9 @@
 
 class WebFrame FINAL : public oxide::WebFrame {
  public:
-  WebFrame(WebFrameAdapter* adapter);
+  WebFrame(WebFrameAdapter* adapter,
+           content::FrameTreeNode* node,
+           oxide::WebView* view);
 
   size_t GetMessageHandlerCount() const FINAL;
   oxide::MessageHandler* GetMessageHandlerAt(size_t index) const FINAL;
@@ -39,7 +41,7 @@
   oxide::OutgoingMessageRequest*
       GetOutgoingMessageRequestAt(size_t index) const FINAL;
 
-  WebFrameAdapter* adapter;
+  WebFrameAdapter* adapter() const { return adapter_; }
 
  private:
   ~WebFrame();
@@ -48,6 +50,8 @@
   void OnChildRemoved(oxide::WebFrame* child) FINAL;
   void OnURLChanged() FINAL;
 
+  WebFrameAdapter* adapter_;
+
   DISALLOW_COPY_AND_ASSIGN(WebFrame);
 };
 

=== added file 'qt/core/browser/oxide_qt_web_preferences.cc'
--- qt/core/browser/oxide_qt_web_preferences.cc	1970-01-01 00:00:00 +0000
+++ qt/core/browser/oxide_qt_web_preferences.cc	2014-02-07 16:51:32 +0000
@@ -0,0 +1,41 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// copyright (c) 2013 canonical ltd.
+
+// this library is free software; you can redistribute it and/or
+// modify it under the terms of the gnu lesser general public
+// license as published by the free software foundation; either
+// version 2.1 of the license, or (at your option) any later version.
+
+// this library is distributed in the hope that it will be useful,
+// but without any warranty; without even the implied warranty of
+// merchantability or fitness for a particular purpose.  see the gnu
+// lesser general public license for more details.
+
+// you should have received a copy of the gnu lesser general public
+// license along with this library; if not, write to the free software
+// foundation, inc., 51 franklin street, fifth floor, boston, ma  02110-1301  usa
+
+#include "oxide_qt_web_preferences.h"
+
+#include <QFont>
+#include <QString>
+
+namespace oxide {
+namespace qt {
+
+WebPreferences::WebPreferences() {
+  QFont font;
+
+  font.setStyleHint(QFont::Serif);
+  SetStandardFontFamily(font.defaultFamily().toStdString());
+  SetSerifFontFamily(font.defaultFamily().toStdString());
+
+  font.setStyleHint(QFont::SansSerif);
+  SetSansSerifFontFamily(font.defaultFamily().toStdString());
+
+  font.setStyleHint(QFont::Monospace);
+  SetFixedFontFamily(font.defaultFamily().toStdString());
+}
+
+} // namespace qt
+} // namespace oxide

=== added file 'qt/core/browser/oxide_qt_web_preferences.h'
--- qt/core/browser/oxide_qt_web_preferences.h	1970-01-01 00:00:00 +0000
+++ qt/core/browser/oxide_qt_web_preferences.h	2014-02-07 16:51:32 +0000
@@ -0,0 +1,34 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// copyright (c) 2013 canonical ltd.
+
+// this library is free software; you can redistribute it and/or
+// modify it under the terms of the gnu lesser general public
+// license as published by the free software foundation; either
+// version 2.1 of the license, or (at your option) any later version.
+
+// this library is distributed in the hope that it will be useful,
+// but without any warranty; without even the implied warranty of
+// merchantability or fitness for a particular purpose.  see the gnu
+// lesser general public license for more details.
+
+// you should have received a copy of the gnu lesser general public
+// license along with this library; if not, write to the free software
+// foundation, inc., 51 franklin street, fifth floor, boston, ma  02110-1301  usa
+
+#ifndef _OXIDE_QT_CORE_BROWSER_WEB_PREFERENCES_H_
+#define _OXIDE_QT_CORE_BROWSER_WEB_PREFERENCES_H_
+
+#include "shared/browser/oxide_web_preferences.h"
+
+namespace oxide {
+namespace qt {
+
+class WebPreferences FINAL : public oxide::WebPreferences {
+ public:
+  WebPreferences();
+};
+
+} // namespace qt
+} // namespace oxide
+
+#endif // _OXIDE_QT_CORE_BROWSER_WEB_PREFERENCES_H_

=== modified file 'qt/core/core.gyp'
--- qt/core/core.gyp	2014-01-31 00:54:49 +0000
+++ qt/core/core.gyp	2014-02-07 16:51:32 +0000
@@ -50,6 +50,7 @@
       ],
       'sources': [
         '<(INTERMEDIATE_DIR)/oxide_qt_web_popup_menu_qquick.moc',
+        'api/internal/oxideqwebpreferences_p.cc',
         'app/oxide_qt_content_main_delegate.cc',
         'app/oxide_qt_content_main_delegate.h',
         'browser/oxide_qt_backing_store.cc',
@@ -64,6 +65,8 @@
         'browser/oxide_qt_web_frame.h',
         'browser/oxide_qt_web_popup_menu.cc',
         'browser/oxide_qt_web_popup_menu.h',
+        'browser/oxide_qt_web_preferences.cc',
+        'browser/oxide_qt_web_preferences.h',
         'common/oxide_qt_content_client.cc',
         'common/oxide_qt_content_client.h',
         'glue/private/oxide_qt_message_handler_adapter_p.cc',
@@ -74,8 +77,6 @@
         'glue/private/oxide_qt_user_script_adapter_p.h',
         'glue/private/oxide_qt_web_context_adapter_p.cc',
         'glue/private/oxide_qt_web_context_adapter_p.h',
-        'glue/private/oxide_qt_web_frame_adapter_p.cc',
-        'glue/private/oxide_qt_web_frame_adapter_p.h',
         'glue/private/oxide_qt_web_view_adapter_p.cc',
         'glue/private/oxide_qt_web_view_adapter_p.h'
       ],
@@ -101,12 +102,16 @@
       'sources': [
         '<(INTERMEDIATE_DIR)/moc_oxideqincomingmessage.cc',
         '<(INTERMEDIATE_DIR)/moc_oxideqloadevent.cc',
+        '<(INTERMEDIATE_DIR)/moc_oxideqwebpreferences.cc',
         'api/oxideqincomingmessage.cc',
         'api/oxideqincomingmessage.h',
         'api/oxideqincomingmessage_p.h',
         'api/oxideqloadevent.cc',
         'api/oxideqloadevent.h',
         'api/oxideqloadevent_p.h',
+        'api/oxideqwebpreferences.cc',
+        'api/oxideqwebpreferences.h',
+        'api/oxideqwebpreferences_p.h',
         'glue/oxide_qt_adapter_base.h',
         'glue/oxide_qt_message_handler_adapter.cc',
         'glue/oxide_qt_message_handler_adapter.h',
@@ -120,6 +125,7 @@
         'glue/oxide_qt_web_context_adapter.h',
         'glue/oxide_qt_web_frame_adapter.cc',
         'glue/oxide_qt_web_frame_adapter.h',
+        'glue/oxide_qt_web_frame_adapter_p.h',
         'glue/oxide_qt_web_popup_menu_delegate.cc',
         'glue/oxide_qt_web_popup_menu_delegate.h',
         'glue/oxide_qt_web_view_adapter.cc',
@@ -136,6 +142,11 @@
           'moc_input': 'api/oxideqloadevent.h',
           'includes': [ 'moc.gypi' ]
         },
+        {
+          'action_name': 'moc_oxideqwebpreferences.cc',
+          'moc_input': 'api/oxideqwebpreferences.h',
+          'includes': [ 'moc.gypi' ]
+        },
       ]
     }
   ]

=== modified file 'qt/core/glue/oxide_qt_web_frame_adapter.cc'
--- qt/core/glue/oxide_qt_web_frame_adapter.cc	2013-10-29 01:06:23 +0000
+++ qt/core/glue/oxide_qt_web_frame_adapter.cc	2014-02-07 16:51:32 +0000
@@ -16,6 +16,7 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 #include "oxide_qt_web_frame_adapter.h"
+#include "oxide_qt_web_frame_adapter_p.h"
 
 #include <QJsonDocument>
 #include <QString>
@@ -25,13 +26,40 @@
 
 #include "qt/core/browser/oxide_qt_web_frame.h"
 #include "qt/core/glue/private/oxide_qt_outgoing_message_request_adapter_p.h"
-#include "qt/core/glue/private/oxide_qt_web_frame_adapter_p.h"
 
 namespace oxide {
 namespace qt {
 
+WebFrameAdapterPrivate::WebFrameAdapterPrivate() :
+    owner(NULL) {}
+
+WebFrameAdapterPrivate::~WebFrameAdapterPrivate() {
+  while (!outgoing_message_requests_.isEmpty()) {
+    RemoveOutgoingMessageRequest(outgoing_message_requests_.first());
+  }
+}
+
+void WebFrameAdapterPrivate::AddOutgoingMessageRequest(
+    OutgoingMessageRequestAdapter* request) {
+  DCHECK(!outgoing_message_requests_.contains(request));
+
+  OutgoingMessageRequestAdapterPrivate::get(request)->frame = this;
+  outgoing_message_requests_.append(request);
+}
+
+void WebFrameAdapterPrivate::RemoveOutgoingMessageRequest(
+    OutgoingMessageRequestAdapter* request) {
+  outgoing_message_requests_.removeOne(request);
+  OutgoingMessageRequestAdapterPrivate::get(request)->frame = NULL;
+}
+
+// static
+WebFrameAdapterPrivate* WebFrameAdapterPrivate::get(WebFrameAdapter* adapter) {
+  return adapter->priv.data();
+}
+
 WebFrameAdapter::WebFrameAdapter() :
-    priv(WebFrameAdapterPrivate::Create()) {}
+    priv(new WebFrameAdapterPrivate()) {}
 
 WebFrameAdapter::~WebFrameAdapter() {}
 

=== renamed file 'qt/core/glue/private/oxide_qt_web_frame_adapter_p.h' => 'qt/core/glue/oxide_qt_web_frame_adapter_p.h'
--- qt/core/glue/private/oxide_qt_web_frame_adapter_p.h	2013-10-29 01:06:23 +0000
+++ qt/core/glue/oxide_qt_web_frame_adapter_p.h	2014-02-07 16:51:32 +0000
@@ -32,7 +32,7 @@
 
 class WebFrameAdapterPrivate FINAL {
  public:
-  static WebFrameAdapterPrivate* Create();
+  WebFrameAdapterPrivate();
   ~WebFrameAdapterPrivate();
 
   const QList<OutgoingMessageRequestAdapter *>& outgoing_message_requests() const {
@@ -47,8 +47,6 @@
   WebFrame* owner;
 
  private:
-  WebFrameAdapterPrivate();
-
   QList<OutgoingMessageRequestAdapter *> outgoing_message_requests_;
 
   DISALLOW_COPY_AND_ASSIGN(WebFrameAdapterPrivate);

=== modified file 'qt/core/glue/oxide_qt_web_view_adapter.cc'
--- qt/core/glue/oxide_qt_web_view_adapter.cc	2013-12-17 19:21:18 +0000
+++ qt/core/glue/oxide_qt_web_view_adapter.cc	2014-02-07 16:51:32 +0000
@@ -20,6 +20,8 @@
 #include "ui/gfx/size.h"
 #include "url/gurl.h"
 
+#include "qt/core/api/oxideqwebpreferences.h"
+#include "qt/core/api/oxideqwebpreferences_p.h"
 #include "qt/core/browser/oxide_qt_web_frame.h"
 #include "qt/core/glue/private/oxide_qt_web_context_adapter_p.h"
 #include "qt/core/glue/private/oxide_qt_web_view_adapter_p.h"
@@ -30,9 +32,14 @@
 namespace qt {
 
 WebViewAdapter::WebViewAdapter() :
-    priv(WebViewAdapterPrivate::Create(this)) {}
+    priv(WebViewAdapterPrivate::Create(this)),
+    preferences_(NULL) {}
 
-WebViewAdapter::~WebViewAdapter() {}
+WebViewAdapter::~WebViewAdapter() {
+  if (preferences_) {
+    OxideQWebPreferencesPrivate::get(preferences_)->RemoveWebView(this);
+  }
+}
 
 void WebViewAdapter::init(WebContextAdapter* context,
                           const QSize& initial_size,
@@ -82,12 +89,7 @@
 }
 
 WebFrameAdapter* WebViewAdapter::rootFrame() const {
-  WebFrame* frame = static_cast<WebFrame *>(priv->GetRootFrame());
-  if (!frame) {
-    return NULL;
-  }
-
-  return frame->adapter;
+  return static_cast<WebFrame *>(priv->GetRootFrame())->adapter();
 }
 
 void WebViewAdapter::updateSize(const QSize& size) {
@@ -123,7 +125,7 @@
 }
 
 bool WebViewAdapter::isInitialized() {
-  return priv->web_contents() != NULL;
+  return priv->GetWebContents() != NULL;
 }
 
 int WebViewAdapter::getNavigationEntryCount() const {
@@ -154,5 +156,38 @@
   return QDateTime::fromMSecsSinceEpoch(priv->GetNavigationEntryTimestamp(index).ToJsTime());
 }
 
+OxideQWebPreferences* WebViewAdapter::preferences() {
+  if (!preferences_) {
+    setPreferences(new OxideQWebPreferences(adapterToQObject(this)));
+  }
+
+  return preferences_;
+}
+
+void WebViewAdapter::setPreferences(OxideQWebPreferences* prefs) {
+  OxideQWebPreferences* old = preferences_;
+  preferences_ = prefs;
+
+  if (prefs) {
+    OxideQWebPreferencesPrivate* pp = OxideQWebPreferencesPrivate::get(prefs);
+    pp->AddWebView(this);
+    priv->SetWebPreferences(&pp->preferences());
+
+    if (!prefs->parent()) {
+      prefs->setParent(adapterToQObject(this));
+    }
+  } else {
+    priv->SetWebPreferences(NULL);
+  }
+
+  if (old) {
+    OxideQWebPreferencesPrivate* pp = OxideQWebPreferencesPrivate::get(old);
+    pp->RemoveWebView(this);
+    if (!pp->in_destructor() && old->parent() == adapterToQObject(this)) {
+      delete old;
+    }
+  }
+}
+
 } // namespace qt
 } // namespace oxide

=== modified file 'qt/core/glue/oxide_qt_web_view_adapter.h'
--- qt/core/glue/oxide_qt_web_view_adapter.h	2014-01-09 00:25:46 +0000
+++ qt/core/glue/oxide_qt_web_view_adapter.h	2014-02-07 16:51:32 +0000
@@ -33,6 +33,7 @@
 QT_END_NAMESPACE
 
 class OxideQLoadEvent;
+class OxideQWebPreferences;
 
 namespace oxide {
 namespace qt {
@@ -89,8 +90,6 @@
 
   virtual void LoadProgressChanged(double progress) = 0;
 
-  virtual void RootFrameChanged() = 0;
-
   virtual void LoadEvent(OxideQLoadEvent* event) = 0;
 
   virtual void NavigationEntryCommitted() = 0;
@@ -113,12 +112,20 @@
   QString getNavigationEntryTitle(int index) const;
   QDateTime getNavigationEntryTimestamp(int index) const;
 
+  OxideQWebPreferences* preferences();
+  void setPreferences(OxideQWebPreferences* prefs);
+  virtual void NotifyWebPreferencesDestroyed() = 0;
+
+  virtual void FrameAdded(WebFrameAdapter* frame) = 0;
+  virtual void FrameRemoved(WebFrameAdapter* frame) = 0;
+
  protected:
   WebViewAdapter();
 
  private:
+  QScopedPointer<WebViewAdapterPrivate> priv;
   QList<MessageHandlerAdapter *> message_handlers_;
-  QScopedPointer<WebViewAdapterPrivate> priv;
+  OxideQWebPreferences* preferences_;
 };
 
 } // namespace qt

=== modified file 'qt/core/glue/private/oxide_qt_message_handler_adapter_p.cc'
--- qt/core/glue/private/oxide_qt_message_handler_adapter_p.cc	2014-01-09 00:10:22 +0000
+++ qt/core/glue/private/oxide_qt_message_handler_adapter_p.cc	2014-02-07 16:51:32 +0000
@@ -43,7 +43,7 @@
 
   *error = !a->OnReceiveMessage(
       qmessage,
-      static_cast<WebFrame *>(message->source_frame())->adapter,
+      static_cast<WebFrame *>(message->source_frame())->adapter(),
       qerror);
 
   if (*error) {

=== modified file 'qt/core/glue/private/oxide_qt_outgoing_message_request_adapter_p.cc'
--- qt/core/glue/private/oxide_qt_outgoing_message_request_adapter_p.cc	2013-10-29 01:06:23 +0000
+++ qt/core/glue/private/oxide_qt_outgoing_message_request_adapter_p.cc	2014-02-07 16:51:32 +0000
@@ -23,8 +23,7 @@
 #include <QVariant>
 
 #include "qt/core/glue/oxide_qt_outgoing_message_request_adapter.h"
-
-#include "oxide_qt_web_frame_adapter_p.h"
+#include "qt/core/glue/oxide_qt_web_frame_adapter_p.h"
 
 namespace oxide {
 namespace qt {

=== removed file 'qt/core/glue/private/oxide_qt_web_frame_adapter_p.cc'
--- qt/core/glue/private/oxide_qt_web_frame_adapter_p.cc	2013-10-29 01:06:23 +0000
+++ qt/core/glue/private/oxide_qt_web_frame_adapter_p.cc	1970-01-01 00:00:00 +0000
@@ -1,64 +0,0 @@
-// vim:expandtab:shiftwidth=2:tabstop=2:
-// Copyright (C) 2013 Canonical Ltd.
-
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// Lesser General Public License for more details.
-
-// You should have received a copy of the GNU Lesser General Public
-// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-
-#include "oxide_qt_web_frame_adapter_p.h"
-
-#include "qt/core/browser/oxide_qt_web_frame.h"
-#include "qt/core/glue/oxide_qt_web_frame_adapter.h"
-
-#include "oxide_qt_outgoing_message_request_adapter_p.h"
-
-namespace oxide {
-namespace qt {
-
-WebFrameAdapterPrivate::WebFrameAdapterPrivate() :
-    owner(NULL) {}
-
-// static
-WebFrameAdapterPrivate* WebFrameAdapterPrivate::Create() {
-  return new WebFrameAdapterPrivate();
-}
-
-WebFrameAdapterPrivate::~WebFrameAdapterPrivate() {
-  while (!outgoing_message_requests_.isEmpty()) {
-    RemoveOutgoingMessageRequest(outgoing_message_requests_.first());
-  }
-
-  owner->adapter = NULL;
-}
-
-void WebFrameAdapterPrivate::AddOutgoingMessageRequest(
-    OutgoingMessageRequestAdapter* request) {
-  DCHECK(!outgoing_message_requests_.contains(request));
-
-  OutgoingMessageRequestAdapterPrivate::get(request)->frame = this;
-  outgoing_message_requests_.append(request);
-}
-
-void WebFrameAdapterPrivate::RemoveOutgoingMessageRequest(
-    OutgoingMessageRequestAdapter* request) {
-  outgoing_message_requests_.removeOne(request);
-  OutgoingMessageRequestAdapterPrivate::get(request)->frame = NULL;
-}
-
-// static
-WebFrameAdapterPrivate* WebFrameAdapterPrivate::get(WebFrameAdapter* adapter) {
-  return adapter->priv.data();
-}
-
-} // namespace qt
-} // namespace oxide

=== modified file 'qt/core/glue/private/oxide_qt_web_view_adapter_p.cc'
--- qt/core/glue/private/oxide_qt_web_view_adapter_p.cc	2014-01-09 00:25:46 +0000
+++ qt/core/glue/private/oxide_qt_web_view_adapter_p.cc	2014-02-07 16:51:32 +0000
@@ -28,10 +28,10 @@
 #include "qt/core/browser/oxide_qt_web_frame.h"
 #include "qt/core/browser/oxide_qt_web_popup_menu.h"
 #include "qt/core/glue/oxide_qt_web_frame_adapter.h"
+#include "qt/core/glue/oxide_qt_web_frame_adapter_p.h"
 #include "qt/core/glue/oxide_qt_web_view_adapter.h"
 
 #include "oxide_qt_message_handler_adapter_p.h"
-#include "oxide_qt_web_frame_adapter_p.h"
 
 namespace oxide {
 namespace qt {
@@ -55,10 +55,6 @@
   a->LoadProgressChanged(progress);
 }
 
-void WebViewAdapterPrivate::OnRootFrameChanged() {
-  a->RootFrameChanged();
-}
-
 void WebViewAdapterPrivate::OnLoadStarted(const GURL& validated_url,
                                           bool is_error_frame) {
   OxideQLoadEvent event(
@@ -104,8 +100,9 @@
   a->NavigationEntryChanged(index);
 }
 
-oxide::WebFrame* WebViewAdapterPrivate::CreateWebFrame() {
-  return new WebFrame(a->CreateWebFrame());
+oxide::WebFrame* WebViewAdapterPrivate::CreateWebFrame(
+    content::FrameTreeNode* node) {
+  return new WebFrame(a->CreateWebFrame(), node, this);
 }
 
 // static
@@ -143,5 +140,13 @@
   return new WebPopupMenu(a->CreateWebPopupMenuDelegate(), rvh);
 }
 
+void WebViewAdapterPrivate::FrameAdded(oxide::WebFrame* frame) {
+  a->FrameAdded(static_cast<WebFrame *>(frame)->adapter());
+}
+
+void WebViewAdapterPrivate::FrameRemoved(oxide::WebFrame* frame) {
+  a->FrameRemoved(static_cast<WebFrame *>(frame)->adapter());
+}
+
 } // namespace qt
 } // namespace oxide

=== modified file 'qt/core/glue/private/oxide_qt_web_view_adapter_p.h'
--- qt/core/glue/private/oxide_qt_web_view_adapter_p.h	2014-01-07 14:48:46 +0000
+++ qt/core/glue/private/oxide_qt_web_view_adapter_p.h	2014-02-07 16:51:32 +0000
@@ -42,6 +42,9 @@
 
   oxide::WebPopupMenu* CreatePopupMenu(content::RenderViewHost* rvh) FINAL;
 
+  void FrameAdded(oxide::WebFrame* frame) FINAL;
+  void FrameRemoved(oxide::WebFrame* frame) FINAL;
+
  private:
   WebViewAdapterPrivate(WebViewAdapter* adapter);
 
@@ -51,8 +54,6 @@
 
   void OnLoadProgressChanged(double progress) FINAL;
 
-  void OnRootFrameChanged() FINAL;
-
   void OnLoadStarted(const GURL& validated_url,
                      bool is_error_frame) FINAL;
   void OnLoadStopped(const GURL& validated_url) FINAL;
@@ -65,7 +66,7 @@
   void OnNavigationListPruned(bool from_front, int count) FINAL;
   void OnNavigationEntryChanged(int index) FINAL;
 
-  oxide::WebFrame* CreateWebFrame() FINAL;
+  oxide::WebFrame* CreateWebFrame(content::FrameTreeNode* node) FINAL;
 
   WebViewAdapter* a;
 

=== modified file 'qt/quick/api/oxideqquickwebframe.cc'
--- qt/quick/api/oxideqquickwebframe.cc	2013-10-28 15:56:40 +0000
+++ qt/quick/api/oxideqquickwebframe.cc	2014-02-07 16:51:32 +0000
@@ -124,11 +124,11 @@
   
   if (event->added()) {
     d->children().append(child);
-    emit childFrameChanged(ChildAdded, child);
   } else if (event->removed()) {
     d->children().removeOne(child);
-    emit childFrameChanged(ChildRemoved, child);
   }
+
+  emit childFramesChanged();
 }
 
 OxideQQuickWebFrame::~OxideQQuickWebFrame() {}

=== modified file 'qt/quick/api/oxideqquickwebframe_p.h'
--- qt/quick/api/oxideqquickwebframe_p.h	2013-11-20 19:02:08 +0000
+++ qt/quick/api/oxideqquickwebframe_p.h	2014-02-07 16:51:32 +0000
@@ -35,18 +35,13 @@
   Q_OBJECT
   Q_PROPERTY(QUrl url READ url NOTIFY urlChanged)
   Q_PROPERTY(OxideQQuickWebFrame* parentFrame READ parentFrame)
-  Q_PROPERTY(QQmlListProperty<OxideQQuickWebFrame> childFrames READ childFrames NOTIFY childFrameChanged)
+  Q_PROPERTY(QQmlListProperty<OxideQQuickWebFrame> childFrames READ childFrames NOTIFY childFramesChanged)
   Q_PROPERTY(QQmlListProperty<OxideQQuickMessageHandler> messageHandlers READ messageHandlers)
   Q_ENUMS(ChildFrameChangedType)
 
   Q_DECLARE_PRIVATE(OxideQQuickWebFrame)
 
  public:
-  enum ChildFrameChangedType {
-    ChildAdded,
-    ChildRemoved
-  };
-
   virtual ~OxideQQuickWebFrame();
 
   QUrl url() const;
@@ -68,8 +63,7 @@
 
  Q_SIGNALS:
   void urlChanged();
-  void childFrameChanged(ChildFrameChangedType type,
-                         OxideQQuickWebFrame* child_frame);
+  void childFramesChanged();
   void messageHandlersChanged();
 
  protected:

=== modified file 'qt/quick/api/oxideqquickwebview.cc'
--- qt/quick/api/oxideqquickwebview.cc	2014-01-20 16:44:30 +0000
+++ qt/quick/api/oxideqquickwebview.cc	2014-02-07 16:51:32 +0000
@@ -19,6 +19,7 @@
 #include "oxideqquickwebview_p_p.h"
 
 #include <QPointF>
+#include <QQmlEngine>
 #include <QQuickWindow>
 #include <QRect>
 #include <QRectF>
@@ -103,19 +104,6 @@
   emit q->loadProgressChanged();
 }
 
-void OxideQQuickWebViewPrivate::RootFrameChanged() {
-  Q_Q(OxideQQuickWebView);
-
-  // Make the webview the QObject parent of the new root frame,
-  // to stop Qml from collecting the frame tree
-  OxideQQuickWebFrame* root = q->rootFrame();
-  if (root) {
-    root->setParent(q);
-  }
-
-  emit q->rootFrameChanged();
-}
-
 void OxideQQuickWebViewPrivate::LoadEvent(OxideQLoadEvent* event) {
   Q_Q(OxideQQuickWebView);
 
@@ -135,7 +123,9 @@
 }
 
 oxide::qt::WebFrameAdapter* OxideQQuickWebViewPrivate::CreateWebFrame() {
-  return OxideQQuickWebFramePrivate::get(new OxideQQuickWebFrame());
+  OxideQQuickWebFrame* frame = new OxideQQuickWebFrame();
+  QQmlEngine::setObjectOwnership(frame, QQmlEngine::CppOwnership);
+  return OxideQQuickWebFramePrivate::get(frame);
 }
 
 QRect OxideQQuickWebViewPrivate::GetContainerBounds() {
@@ -151,6 +141,27 @@
                 q->width(), q->height()).toRect();
 }
 
+void OxideQQuickWebViewPrivate::NotifyWebPreferencesDestroyed() {
+  Q_Q(OxideQQuickWebView);
+
+  qWarning() << "WebPreferences was destroyed whilst still in use";
+  q->setPreferences(NULL);
+}
+
+void OxideQQuickWebViewPrivate::FrameAdded(
+    oxide::qt::WebFrameAdapter* frame) {
+  Q_Q(OxideQQuickWebView);
+
+  emit q->frameAdded(adapterToQObject<OxideQQuickWebFrame>(frame));
+}
+
+void OxideQQuickWebViewPrivate::FrameRemoved(
+    oxide::qt::WebFrameAdapter* frame) {
+  Q_Q(OxideQQuickWebView);
+
+  emit q->frameRemoved(adapterToQObject<OxideQQuickWebFrame>(frame));
+}
+
 void OxideQQuickWebViewPrivate::componentComplete() {
   Q_Q(OxideQQuickWebView);
 
@@ -291,6 +302,10 @@
   QQuickItem::componentComplete();
 
   d->componentComplete();
+
+  // Make the webview the QObject parent of the new root frame,
+  // to stop Qml from collecting the frame tree
+  rootFrame()->setParent(this);
 }
 
 QUrl OxideQQuickWebView::url() const {
@@ -452,6 +467,23 @@
   d->context = context;
 }
 
+OxideQWebPreferences* OxideQQuickWebView::preferences() {
+  Q_D(OxideQQuickWebView);
+
+  return d->preferences();
+}
+
+void OxideQQuickWebView::setPreferences(OxideQWebPreferences* prefs) {
+  Q_D(OxideQQuickWebView);
+
+  if (prefs == d->preferences()) {
+    return;
+  }
+
+  d->setPreferences(prefs);
+  emit preferencesChanged();
+}
+
 OxideQQuickNavigationHistory* OxideQQuickWebView::navigationHistory() {
   Q_D(OxideQQuickWebView);
 

=== modified file 'qt/quick/api/oxideqquickwebview_p.h'
--- qt/quick/api/oxideqquickwebview_p.h	2014-01-07 14:48:46 +0000
+++ qt/quick/api/oxideqquickwebview_p.h	2014-02-07 16:51:32 +0000
@@ -32,6 +32,7 @@
 QT_USE_NAMESPACE
 
 class OxideQLoadEvent;
+class OxideQWebPreferences;
 class OxideQQuickMessageHandler;
 class OxideQQuickNavigationHistory;
 class OxideQQuickWebContext;
@@ -63,12 +64,13 @@
   Q_PROPERTY(bool incognito READ incognito WRITE setIncognito)
   Q_PROPERTY(bool loading READ loading NOTIFY loadingChanged)
   Q_PROPERTY(int loadProgress READ loadProgress NOTIFY loadProgressChanged)
-  Q_PROPERTY(OxideQQuickWebFrame* rootFrame READ rootFrame NOTIFY rootFrameChanged)
+  Q_PROPERTY(OxideQQuickWebFrame* rootFrame READ rootFrame CONSTANT)
   Q_PROPERTY(QQmlListProperty<OxideQQuickMessageHandler> messageHandlers READ messageHandlers NOTIFY messageHandlersChanged)
 
   Q_PROPERTY(QQmlComponent* popupMenu READ popupMenu WRITE setPopupMenu NOTIFY popupMenuChanged)
 
   Q_PROPERTY(OxideQQuickWebContext* context READ context WRITE setContext)
+  Q_PROPERTY(OxideQWebPreferences* preferences READ preferences WRITE setPreferences NOTIFY preferencesChanged)
 
   Q_PROPERTY(OxideQQuickNavigationHistory* navigationHistory READ navigationHistory CONSTANT)
 
@@ -107,6 +109,9 @@
   OxideQQuickWebContext* context() const;
   void setContext(OxideQQuickWebContext* context);
 
+  OxideQWebPreferences* preferences();
+  void setPreferences(OxideQWebPreferences* prefs);
+
   OxideQQuickNavigationHistory* navigationHistory();
 
   static OxideQQuickWebViewAttached* qmlAttachedProperties(QObject* object);
@@ -123,8 +128,10 @@
   void navigationHistoryChanged();
   void loadingChanged(OxideQLoadEvent* loadEvent);
   void loadProgressChanged();
-  void rootFrameChanged();
+  void frameAdded(OxideQQuickWebFrame* frame);
+  void frameRemoved(OxideQQuickWebFrame* frame);
   void popupMenuChanged();
+  void preferencesChanged();
   void messageHandlersChanged();
 
  private Q_SLOTS:

=== modified file 'qt/quick/api/oxideqquickwebview_p_p.h'
--- qt/quick/api/oxideqquickwebview_p_p.h	2014-01-09 00:25:46 +0000
+++ qt/quick/api/oxideqquickwebview_p_p.h	2014-02-07 16:51:32 +0000
@@ -61,8 +61,6 @@
 
   void LoadProgressChanged(double progress) Q_DECL_FINAL;
 
-  void RootFrameChanged() Q_DECL_FINAL;
-
   void LoadEvent(OxideQLoadEvent* event) Q_DECL_FINAL;
 
   void NavigationEntryCommitted() Q_DECL_FINAL;
@@ -73,6 +71,11 @@
 
   QRect GetContainerBounds() Q_DECL_FINAL;
 
+  void NotifyWebPreferencesDestroyed() Q_DECL_FINAL;
+
+  void FrameAdded(oxide::qt::WebFrameAdapter* frame) Q_DECL_FINAL;
+  void FrameRemoved(oxide::qt::WebFrameAdapter* frame) Q_DECL_FINAL;
+
   void componentComplete();
 
   static void messageHandler_append(

=== modified file 'qt/quick/oxide_qml_plugin.cc'
--- qt/quick/oxide_qml_plugin.cc	2014-01-21 00:47:58 +0000
+++ qt/quick/oxide_qml_plugin.cc	2014-02-07 16:51:32 +0000
@@ -23,6 +23,7 @@
 
 #include "qt/core/api/oxideqincomingmessage.h"
 #include "qt/core/api/oxideqloadevent.h"
+#include "qt/core/api/oxideqwebpreferences.h"
 #include "qt/quick/api/oxideqquickglobals_p.h"
 #include "qt/quick/api/oxideqquickmessagehandler_p.h"
 #include "qt/quick/api/oxideqquicknavigationhistory_p.h"
@@ -68,6 +69,7 @@
     qmlRegisterType<OxideQQuickWebContext>(uri, 0, 1, "WebContext");
     qmlRegisterUncreatableType<OxideQQuickNavigationHistory>(uri, 0, 1, "NavigationHistory",
         "Each WebView has a NavigationHistory automatically instantiated by Oxide");
+    qmlRegisterType<OxideQWebPreferences>(uri, 0, 1, "WebPreferences");
     qmlRegisterType<OxideQQuickWebView>(uri, 0, 1, "WebView");
   }
 };

=== modified file 'qt/tests/qmltests/api/tst_WebFrame_tree.qml'
--- qt/tests/qmltests/api/tst_WebFrame_tree.qml	2013-11-20 19:02:08 +0000
+++ qt/tests/qmltests/api/tst_WebFrame_tree.qml	2014-02-07 16:51:32 +0000
@@ -9,39 +9,21 @@
   width: 200
   height: 200
 
-  SignalSpy {
-    id: rootFrameSpy
-    target: webView
-    signalName: "rootFrameChanged"
-  }
-
-  Item {
-    id: spy
-
-    readonly property alias eventLog: spy.qtest_eventLog
-
-    function clear() {
-      qtest_eventLog = [];
-    }
-
-    function childFrameChanged(type, frame) {
-      qtest_eventLog.push({ type: type, frame: frame.toString() });
-
-      if (type == WebFrame.ChildAdded) {
-        frame.childFrameChanged.connect(childFrameChanged);
-      }      
-    }
-
-    function rootFrameChanged() {
-      webView.rootFrame.childFrameChanged.connect(childFrameChanged);
-    }
-
-    property var qtest_eventLog: []
-
-    Component.onCompleted: {
-      webView.rootFrameChanged.connect(rootFrameChanged);
-    }
-  }
+  readonly property alias frameEvents: webView.qtest_frameEvents
+
+  function clearFrameEvents() {
+    qtest_frameEvents = [];
+  }
+
+  onFrameAdded: {
+    qtest_frameEvents.push({type: "added", frame: frame.toString()});
+  }
+
+  onFrameRemoved: {
+    qtest_frameEvents.push({type: "removed", frame: frame.toString()});
+  }
+
+  property var qtest_frameEvents: []
 
   TestCase {
     id: test
@@ -53,26 +35,27 @@
       verify(webView.waitForLoadSucceeded(),
              "Timed out waiting for successful load");
 
-      spy.clear();
-      rootFrameSpy.clear();
+      webView.clearFrameEvents();
     }
 
     function verify_events(data) {
-      compare(spy.eventLog.length, data.length, "Unexpected number of events");
+      compare(webView.frameEvents.length, data.length, "Unexpected number of events");
       for (var i = 0; i < data.length; ++i) {
-        if (i >= spy.eventLog.length) {
+        if (i >= webView.frameEvents.length) {
           break;
         }
-        compare(spy.eventLog[i].type, data[i].type, "Unexpected event type");
-        compare(spy.eventLog[i].frame, data[i].frame, "Unexpected frame");
+        compare(webView.frameEvents[i].type, data[i].type, "Unexpected event type");
+        compare(webView.frameEvents[i].frame, data[i].frame, "Unexpected frame");
       }
 
-      spy.clear();
+      webView.clearFrameEvents();
     }
 
     function verify_tree() {
       compare(webView.rootFrame.parentFrame, null,
               "Root frame should have no parent");
+      compare(Utils.qObjectParent(webView.rootFrame), webView,
+              "Root frame should be a qobject child of the webview");
 
       var queue = [];
       queue.push(webView.rootFrame);
@@ -82,6 +65,8 @@
         for (var i = 0; i < frame.childFrames.length; ++i) {
           compare(frame.childFrames[i].parentFrame, frame,
                   "Incorrect parent");
+          compare(Utils.qObjectParent(frame.childFrames[i]), frame,
+                  "Incorrect qobject parent");
           queue.push(frame.childFrames[i]);
         }
       }
@@ -92,16 +77,14 @@
       verify(webView.waitForLoadSucceeded(),
              "Timed out waiting for successful load");
 
-      compare(rootFrameSpy.count, 0, "Should have the same root frame");
-
       var frames1 = [
         webView.rootFrame.childFrames[0].toString(),
         webView.rootFrame.childFrames[1].toString()
       ];
 
       verify_events([
-        { type: WebFrame.ChildAdded, frame: frames1[0] },
-        { type: WebFrame.ChildAdded, frame: frames1[1] }
+        { type: "added", frame: frames1[0] },
+        { type: "added", frame: frames1[1] }
       ]);
       verify_tree();
 
@@ -109,8 +92,6 @@
       verify(webView.waitForLoadSucceeded(),
              "Timed out waiting for successful load");
 
-      compare(rootFrameSpy.count, 0, "Should have the same root frame");
-
       var frames2 = [
         webView.rootFrame.childFrames[0].toString(),
         webView.rootFrame.childFrames[1].toString(),
@@ -119,12 +100,12 @@
       ];
 
       verify_events([
-        { type: WebFrame.ChildRemoved, frame: frames1[1] },
-        { type: WebFrame.ChildRemoved, frame: frames1[0] },
-        { type: WebFrame.ChildAdded, frame: frames2[0] },
-        { type: WebFrame.ChildAdded, frame: frames2[1] },
-        { type: WebFrame.ChildAdded, frame: frames2[2] },
-        { type: WebFrame.ChildAdded, frame: frames2[3] }
+        { type: "removed", frame: frames1[1] },
+        { type: "removed", frame: frames1[0] },
+        { type: "added", frame: frames2[0] },
+        { type: "added", frame: frames2[1] },
+        { type: "added", frame: frames2[2] },
+        { type: "added", frame: frames2[3] }
       ]);
       verify_tree();
 
@@ -132,20 +113,18 @@
       verify(webView.waitForLoadSucceeded(),
              "Timed out waiting for successful load");
 
-      compare(rootFrameSpy.count, 0, "Should have the same root frame");
-
       frames1 = [
         webView.rootFrame.childFrames[0].toString(),
         webView.rootFrame.childFrames[1].toString()
       ];
 
       verify_events([
-        { type: WebFrame.ChildRemoved, frame: frames2[1] },
-        { type: WebFrame.ChildRemoved, frame: frames2[3] },
-        { type: WebFrame.ChildRemoved, frame: frames2[2] },
-        { type: WebFrame.ChildRemoved, frame: frames2[0] },
-        { type: WebFrame.ChildAdded, frame: frames1[0] },
-        { type: WebFrame.ChildAdded, frame: frames1[1] }
+        { type: "removed", frame: frames2[1] },
+        { type: "removed", frame: frames2[3] },
+        { type: "removed", frame: frames2[2] },
+        { type: "removed", frame: frames2[0] },
+        { type: "added", frame: frames1[0] },
+        { type: "added", frame: frames1[1] }
       ]);
       verify_tree();
     }
@@ -155,8 +134,6 @@
       verify(webView.waitForLoadSucceeded(),
              "Timed out waiting for successful load");
 
-      compare(rootFrameSpy.count, 1, "Should have a new root frame");
-
       var frames = [
         webView.rootFrame.childFrames[0].toString(),
         webView.rootFrame.childFrames[1].toString(),
@@ -165,10 +142,10 @@
       ];
 
       verify_events([
-        { type: WebFrame.ChildAdded, frame: frames[0] },
-        { type: WebFrame.ChildAdded, frame: frames[1] },
-        { type: WebFrame.ChildAdded, frame: frames[2] },
-        { type: WebFrame.ChildAdded, frame: frames[3] }
+        { type: "added", frame: frames[0] },
+        { type: "added", frame: frames[1] },
+        { type: "added", frame: frames[2] },
+        { type: "added", frame: frames[3] }
       ]);
       verify_tree();
 
@@ -176,13 +153,11 @@
       verify(webView.waitForLoadSucceeded(),
              "Timed out waiting for successful load");
 
-      compare(rootFrameSpy.count, 2, "Should have a new root frame");
-
       verify_events([
-        { type: WebFrame.ChildRemoved, frame: frames[1] },
-        { type: WebFrame.ChildRemoved, frame: frames[3] },
-        { type: WebFrame.ChildRemoved, frame: frames[2] },
-        { type: WebFrame.ChildRemoved, frame: frames[0] }
+        { type: "removed", frame: frames[2] },
+        { type: "removed", frame: frames[3] },
+        { type: "removed", frame: frames[0] },
+        { type: "removed", frame: frames[1] }
       ]);
       verify_tree();
 
@@ -190,8 +165,6 @@
       verify(webView.waitForLoadSucceeded(),
              "Timed out waiting for successful load");
 
-      compare(rootFrameSpy.count, 3, "Should have a new root frame");
-
       frames = [
         webView.rootFrame.childFrames[0].toString(),
         webView.rootFrame.childFrames[1].toString(),
@@ -200,10 +173,10 @@
       ];
 
       verify_events([
-        { type: WebFrame.ChildAdded, frame: frames[0] },
-        { type: WebFrame.ChildAdded, frame: frames[1] },
-        { type: WebFrame.ChildAdded, frame: frames[2] },
-        { type: WebFrame.ChildAdded, frame: frames[3] }
+        { type: "added", frame: frames[0] },
+        { type: "added", frame: frames[1] },
+        { type: "added", frame: frames[2] },
+        { type: "added", frame: frames[3] }
       ]);
       verify_tree();
     }

=== modified file 'qt/tests/qmltests/api/tst_WebFrame_url.qml'
--- qt/tests/qmltests/api/tst_WebFrame_url.qml	2013-10-08 16:00:27 +0000
+++ qt/tests/qmltests/api/tst_WebFrame_url.qml	2014-02-07 16:51:32 +0000
@@ -13,7 +13,7 @@
     signalName: "urlChanged"
   }
 
-  onRootFrameChanged: {
+  Component.onCompleted: {
     spy.target = webView.rootFrame;
   }
 

=== added file 'qt/tests/qmltests/api/tst_WebView_preferences.qml'
--- qt/tests/qmltests/api/tst_WebView_preferences.qml	1970-01-01 00:00:00 +0000
+++ qt/tests/qmltests/api/tst_WebView_preferences.qml	2014-02-07 16:51:32 +0000
@@ -0,0 +1,64 @@
+import QtQuick 2.0
+import QtTest 1.0
+import com.canonical.Oxide 0.1
+import com.canonical.Oxide.Testing 0.1
+
+TestWebView {
+  id: webView
+  focus: true
+  width: 200
+  height: 200
+
+  SignalSpy {
+    id: spy
+    target: webView
+    signalName: "preferencesChanged"
+  }
+
+  Component {
+    id: webPreferences
+    WebPreferences {}
+  }
+
+  TestCase {
+    id: test
+    name: "WebView_preferences"
+    when: windowShown
+
+    function test_WebView_preferences() {
+      verify(webView.preferences, "No default preferences");
+      compare(spy.count, 0,
+              "Constructing the default shouldn't have caused a signal");
+      compare(OxideTestingUtils.qObjectParent(webView.preferences), webView,
+              "WebView should own its default preferences");
+
+      var destructionObserver = OxideTestingUtils.createDestructionObserver(
+          webView.preferences);
+      var newPrefs = webPreferences.createObject(null, {});
+      webView.preferences = newPrefs;
+
+      compare(spy.count, 1,
+              "Assigning a new preference object should have caused a signal");
+      compare(webView.preferences, newPrefs,
+              "Should have a new preference object");
+      compare(OxideTestingUtils.qObjectParent(webView.preferences), webView,
+              "WebView should own its default preferences");
+      gc();
+      verify(webView.waitFor(function() { return destructionObserver.destroyed; }),
+             "The default preference object should have been destroyed");
+
+      destructionObserver = OxideTestingUtils.createDestructionObserver(
+          webView.preferences);
+      var oldSetting = webView.preferences.javascriptEnabled = !webView.preferences.javascriptEnabled;
+      webView.preferences.destroy();
+      gc();
+      verify(webView.waitFor(function() { return destructionObserver.destroyed; }));
+
+      compare(spy.count, 2,
+              "Deleting our preference object should have caused a signal");
+      verify(webView.preferences, "Should have default preferences again");
+      compare(webView.preferences.javascriptEnabled, !oldSetting,
+              "We still have the old preferences object");
+    }
+  }
+}

=== modified file 'qt/tests/qmltests/api/tst_WebView_rootFrame.qml'
--- qt/tests/qmltests/api/tst_WebView_rootFrame.qml	2013-10-08 13:58:54 +0000
+++ qt/tests/qmltests/api/tst_WebView_rootFrame.qml	2014-02-07 16:51:32 +0000
@@ -13,39 +13,21 @@
     name: "WebView_rootFrame"
     when: windowShown
 
-    SignalSpy {
-      id: spy
-      target: webView
-      signalName: "rootFrameChanged"
+    function test_WebView_rootFrame1_parent() {
+      verify(webView.rootFrame, "Should always have a root frame");
+      compare(Utils.qObjectParent(webView.rootFrame), webView,
+              "The root frame should be parented to the webview");
     }
 
-    function test_WebView_rootFrame1() {
-      verify(!webView.rootFrame, "Shouldn't have a frame yet");
-
-      webView.url = "http://localhost:8080/tst_WebView_rootFrame.html";
-      verify(webView.waitForLoadSucceeded(),
-             "Timed out waiting for successful load");
-
-      compare(spy.count, 1, "Should have a root frame");
-      verify(webView.rootFrame, "Should have a root frame");
-
-      var root = webView.rootFrame;
-
-      webView.url = "about:blank";
-      verify(webView.waitForLoadSucceeded(),
-             "Timed out waiting for successful load");
-
-      compare(spy.count, 2, "Should have a new root frame");
-      verify(webView.rootFrame, "Should have a root frame");
-
-      compare(root.sendMessage, undefined, "The old root frame should no longer exist");
-
-      webView.goBack();
-      verify(webView.waitForLoadSucceeded(),
-             "Timed out waiting for successful load");
-
-      compare(spy.count, 3, "Should have the old root frame back again now");
-      verify(webView.rootFrame, "Should have a root frame");
+    function test_WebView_rootFrame2_undeletable() {
+      var caught = false;
+      try {
+        webView.rootFrame.destroy();
+      } catch(e) {
+        caught = true;
+      }
+
+      verify(caught, "WebView.rootFrame.destroy() should have thrown");
     }
   }
 }

=== modified file 'qt/tests/qmltests/oxide_qml_testing_plugin.cc'
--- qt/tests/qmltests/oxide_qml_testing_plugin.cc	2014-01-25 11:15:30 +0000
+++ qt/tests/qmltests/oxide_qml_testing_plugin.cc	2014-02-07 16:51:32 +0000
@@ -82,6 +82,14 @@
     return url;
   }
 
+  Q_INVOKABLE QObject* qObjectParent(QObject* object) {
+    if (!object) {
+      return NULL;
+    }
+
+    return object->parent();
+  }
+
   Q_INVOKABLE DestructionObserver* createDestructionObserver(QObject* object) {
     if (!object) {
       return NULL;

=== modified file 'shared/app/oxide_content_main_delegate.cc'
--- shared/app/oxide_content_main_delegate.cc	2014-01-30 10:57:52 +0000
+++ shared/app/oxide_content_main_delegate.cc	2014-02-07 16:51:32 +0000
@@ -105,6 +105,11 @@
     // This is needed so that we can share GL resources with the embedder
     command_line->AppendSwitch(switches::kInProcessGPU);
 
+    command_line->AppendSwitch(switches::kEnableViewport);
+    command_line->AppendSwitch(switches::kEnableViewportMeta);
+    command_line->AppendSwitch(switches::kEnablePinch);
+    command_line->AppendSwitch(switches::kEnableOverlayScrollbars);
+
     const char* renderer_cmd_prefix = getenv("OXIDE_RENDERER_CMD_PREFIX");
     if (renderer_cmd_prefix) {
       command_line->AppendSwitchASCII(switches::kRendererCmdPrefix,
@@ -113,6 +118,9 @@
     if (getenv("OXIDE_NO_SANDBOX")) {
       command_line->AppendSwitch(switches::kNoSandbox);
     }
+    if (getenv("OXIDE_SINGLE_PROCESS")) {
+      command_line->AppendSwitch(switches::kSingleProcess);
+    }
   }
 
   return false;

=== modified file 'shared/browser/oxide_content_browser_client.cc'
--- shared/browser/oxide_content_browser_client.cc	2014-01-13 22:06:04 +0000
+++ shared/browser/oxide_content_browser_client.cc	2014-02-07 16:51:32 +0000
@@ -44,8 +44,11 @@
 
 #include "oxide_browser_context.h"
 #include "oxide_browser_process_main.h"
+#include "oxide_message_dispatcher_browser.h"
 #include "oxide_message_pump.h"
 #include "oxide_web_contents_view.h"
+#include "oxide_web_preferences.h"
+#include "oxide_web_view.h"
 
 namespace oxide {
 
@@ -213,10 +216,11 @@
   return view;
 }
 
-void ContentBrowserClient::RenderProcessHostCreated(
+void ContentBrowserClient::RenderProcessWillLaunch(
     content::RenderProcessHost* host) {
   host->Send(new OxideMsg_SetIsIncognitoProcess(
       host->GetBrowserContext()->IsOffTheRecord()));
+  host->AddFilter(new MessageDispatcherBrowser(host->GetID()));
 }
 
 net::URLRequestContextGetter* ContentBrowserClient::CreateRequestContext(
@@ -260,17 +264,11 @@
 void ContentBrowserClient::OverrideWebkitPrefs(
     content::RenderViewHost* render_view_host,
     const GURL& url,
-    WebPreferences* prefs) {
-  // XXX: This is temporary until we expose a WebPreferences API
-  if (getenv("OXIDE_ENABLE_COMPOSITING") &&
-      g_main_parts->shared_gl_context() &&
-      g_main_parts->shared_gl_context()->GetImplementation() ==
-          gfx::GetGLImplementation()) {
-    prefs->force_compositing_mode = true;
-    prefs->accelerated_compositing_enabled = true;
-  } else {
-    prefs->force_compositing_mode = false;
-    prefs->accelerated_compositing_enabled = false;
+    ::WebPreferences* prefs) {
+  WebView* view = WebView::FromRenderViewHost(render_view_host);
+  WebPreferences* web_prefs = view->GetWebPreferences();
+  if (web_prefs) {
+    web_prefs->ApplyToWebkitPrefs(prefs);
   }
 }
 
@@ -290,4 +288,8 @@
 void ContentBrowserClient::GetAllowedGLImplementations(
     std::vector<gfx::GLImplementation>* impls) {}
 
+WebPreferences* ContentBrowserClient::GetDefaultWebPreferences() {
+  return NULL;
+}
+
 } // namespace oxide

=== modified file 'shared/browser/oxide_content_browser_client.h'
--- shared/browser/oxide_content_browser_client.h	2014-01-13 22:06:04 +0000
+++ shared/browser/oxide_content_browser_client.h	2014-02-07 16:51:32 +0000
@@ -47,6 +47,7 @@
 class GLShareGroup;
 class SharedGLContext;
 class WebFrameTree;
+class WebPreferences;
 
 class ContentBrowserClient : public content::ContentBrowserClient {
  public:
@@ -60,7 +61,7 @@
       content::RenderViewHostDelegateView** render_view_host_delegate_view)
       FINAL;
 
-  void RenderProcessHostCreated(content::RenderProcessHost* host) FINAL;
+  void RenderProcessWillLaunch(content::RenderProcessHost* host) FINAL;
 
   net::URLRequestContextGetter* CreateRequestContext(
       content::BrowserContext* browser_context,
@@ -80,7 +81,7 @@
 
   void OverrideWebkitPrefs(content::RenderViewHost* render_view_host,
                            const GURL& url,
-                           WebPreferences* prefs) FINAL;
+                           ::WebPreferences* prefs) FINAL;
 
   gfx::GLShareGroup* GetGLShareGroup() FINAL;
 
@@ -94,6 +95,8 @@
 
   virtual void GetDefaultScreenInfo(blink::WebScreenInfo* result) = 0;
 
+  virtual WebPreferences* GetDefaultWebPreferences();
+
  protected:
   // Limit default constructor access to derived classes
   ContentBrowserClient();

=== modified file 'shared/browser/oxide_incoming_message.cc'
--- shared/browser/oxide_incoming_message.cc	2013-11-20 19:02:08 +0000
+++ shared/browser/oxide_incoming_message.cc	2014-02-07 16:51:32 +0000
@@ -17,13 +17,12 @@
 
 #include "oxide_incoming_message.h"
 
-#include "content/public/browser/render_view_host.h"
-#include "content/public/browser/web_contents.h"
+#include "content/browser/frame_host/frame_tree_node.h"
+#include "content/public/browser/render_frame_host.h"
 
 #include "shared/common/oxide_messages.h"
 
 #include "oxide_web_frame.h"
-#include "oxide_web_view.h"
 
 namespace oxide {
 
@@ -46,18 +45,15 @@
   }
 
   OxideMsg_SendMessage_Params params;
-  params.frame_id = source_frame()->identifier();
   params.world_id = world_id_;
   params.serial = serial_;
   params.type = OxideMsg_SendMessage_Type::Reply;
   params.error = OxideMsg_SendMessage_Error::OK;
-  params.args = args;
+  params.payload = args;
 
-  // FIXME: This is clearly broken for OOPIF
-  content::WebContents* web_contents = source_frame()->view()->web_contents();
-  web_contents->Send(new OxideMsg_SendMessage(
-      web_contents->GetRenderViewHost()->GetRoutingID(),
-      params));
+  content::RenderFrameHost* rfh =
+      source_frame()->frame_tree_node()->current_frame_host();
+  rfh->Send(new OxideMsg_SendMessage(rfh->GetRoutingID(), params));
 }
 
 void IncomingMessage::Error(const std::string& msg) {
@@ -67,18 +63,15 @@
   }
 
   OxideMsg_SendMessage_Params params;
-  params.frame_id = source_frame()->identifier();
   params.world_id = world_id_;
   params.serial = serial_;
   params.type = OxideMsg_SendMessage_Type::Reply;
   params.error = OxideMsg_SendMessage_Error::HANDLER_REPORTED_ERROR;
-  params.args = msg;
+  params.payload = msg;
 
-  // FIXME: This is clearly broken for OOPIF
-  content::WebContents* web_contents = source_frame()->view()->web_contents();
-  web_contents->Send(new OxideMsg_SendMessage(
-      web_contents->GetRenderViewHost()->GetRoutingID(),
-      params));
+  content::RenderFrameHost* rfh =
+      source_frame()->frame_tree_node()->current_frame_host();
+  rfh->Send(new OxideMsg_SendMessage(rfh->GetRoutingID(), params));
 }
 
 } // namespace oxide

=== added file 'shared/browser/oxide_message_dispatcher_browser.cc'
--- shared/browser/oxide_message_dispatcher_browser.cc	1970-01-01 00:00:00 +0000
+++ shared/browser/oxide_message_dispatcher_browser.cc	2014-02-07 16:51:32 +0000
@@ -0,0 +1,209 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2013 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#include "oxide_message_dispatcher_browser.h"
+
+#include <string>
+#include <vector>
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/logging.h"
+#include "content/browser/frame_host/render_frame_host_impl.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/render_process_host.h"
+#include "ipc/ipc_message.h"
+#include "ipc/ipc_message_macros.h"
+
+#include "shared/common/oxide_messages.h"
+
+#include "oxide_incoming_message.h"
+#include "oxide_message_handler.h"
+#include "oxide_message_target.h"
+#include "oxide_outgoing_message_request.h"
+#include "oxide_web_frame.h"
+#include "oxide_web_view.h"
+
+namespace oxide {
+
+namespace {
+
+class MessageReceiver {
+ public:
+  MessageReceiver(int render_process_id, int routing_id) :
+      render_process_id_(render_process_id),
+      routing_id_(routing_id) {}
+
+  ~MessageReceiver() {}
+
+  void OnReceiveMessage(const OxideMsg_SendMessage_Params& params) {
+    params_ = params;
+
+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI, FROM_HERE,
+        base::Bind(&MessageReceiver::ReceiveMessageOnUIThread,
+                   base::Owned(this)));
+  }
+
+  void ReceiveMessageOnUIThread() {
+    bool is_reply = params_.type == OxideMsg_SendMessage_Type::Reply;
+
+    content::RenderFrameHostImpl* rfh =
+        content::RenderFrameHostImpl::FromID(render_process_id_, routing_id_);
+    if (!rfh) {
+      if (!is_reply) {
+        ReturnError(NULL, OxideMsg_SendMessage_Error::INVALID_DESTINATION,
+                    "Could not find a RenderFrameHost corresponding to the "
+                    "specified routing ID");
+      }
+      return;
+    }
+
+    WebFrame* frame = WebFrame::FromFrameTreeNode(rfh->frame_tree_node());
+    if (!frame) {
+      if (!is_reply) {
+        ReturnError(rfh, OxideMsg_SendMessage_Error::INVALID_DESTINATION,
+                    "The RenderFrameHost does not have a corresponding WebFrame");
+      }
+      return;
+    }
+
+    if (!is_reply) {
+      if (params_.type != OxideMsg_SendMessage_Type::Message) {
+        LOG(ERROR) << "Invalid message type from renderer";
+        rfh->GetProcess()->ReceivedBadMessage();
+        return;
+      }
+
+      WebFrame* target = frame;
+      WebView* view = frame->view();
+
+      while (target) {
+        DCHECK_EQ(target->view(), view);
+        if (TryDispatchMessageToTarget(target, frame)) {
+          break;
+        }
+
+        target = target->parent();
+      }
+
+      if (!target && !TryDispatchMessageToTarget(view, frame)) {
+        ReturnError(
+            rfh, OxideMsg_SendMessage_Error::NO_HANDLER,
+            std::string("Could not find a handler for message"));
+      }
+
+      return;
+    }
+
+    for (size_t i = 0; i < frame->GetOutgoingMessageRequestCount(); ++i) {
+      OutgoingMessageRequest* request = frame->GetOutgoingMessageRequestAt(i);
+
+      if (request->serial() == params_.serial) {
+        request->OnReceiveResponse(params_.payload, params_.error);
+        return;
+      }
+    }
+  }
+
+ private:
+  bool TryDispatchMessageToTarget(MessageTarget* target,
+                                  WebFrame* source_frame) {
+    for (size_t i = 0; i < target->GetMessageHandlerCount(); ++i) {
+      MessageHandler* handler = target->GetMessageHandlerAt(i);
+
+      if (!handler->IsValid()) {
+        continue;
+      }
+
+      if (handler->msg_id() != params_.msg_id) {
+        continue;
+      }
+
+      const std::vector<std::string>& world_ids = handler->world_ids();
+
+      for (std::vector<std::string>::const_iterator it = world_ids.begin();
+           it != world_ids.end(); ++it) {
+        if ((*it) == params_.world_id) {
+          handler->OnReceiveMessage(
+              new IncomingMessage(source_frame, params_.serial,
+                                  params_.world_id, params_.msg_id,
+                                  params_.payload));
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  void ReturnError(content::RenderFrameHost* rfh,
+                   OxideMsg_SendMessage_Error::Value type,
+                   const std::string& msg) {
+    OxideMsg_SendMessage_Params params;
+    params.world_id = params_.world_id;
+    params.serial = params_.serial;
+    params.type = OxideMsg_SendMessage_Type::Reply;
+    params.msg_id = params_.msg_id;
+
+    params.error = type;
+    params.payload = msg;
+
+    content::RenderProcessHost* process = NULL;
+    if (rfh) {
+      process = rfh->GetProcess();
+    }
+    if (!process) {
+      process = content::RenderProcessHost::FromID(render_process_id_);
+    }
+    if (!process) {
+      return;
+    }
+
+    process->Send(new OxideMsg_SendMessage(routing_id_, params));
+  }
+
+  OxideMsg_SendMessage_Params params_;
+
+  const int render_process_id_;
+  const int routing_id_;
+};
+
+} // namespace
+
+MessageDispatcherBrowser::MessageDispatcherBrowser(
+    int render_process_id) :
+    render_process_id_(render_process_id) {}
+
+MessageDispatcherBrowser::~MessageDispatcherBrowser() {}
+
+bool MessageDispatcherBrowser::OnMessageReceived(const IPC::Message& message,
+                                                 bool* message_was_ok) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP_EX(MessageDispatcherBrowser, message, *message_was_ok)
+    IPC_MESSAGE_FORWARD(OxideHostMsg_SendMessage,
+                        new MessageReceiver(render_process_id_,
+                                            message.routing_id()),
+                        MessageReceiver::OnReceiveMessage)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP_EX()
+
+  return handled;
+}
+
+} // namespace oxide

=== added file 'shared/browser/oxide_message_dispatcher_browser.h'
--- shared/browser/oxide_message_dispatcher_browser.h	1970-01-01 00:00:00 +0000
+++ shared/browser/oxide_message_dispatcher_browser.h	2014-02-07 16:51:32 +0000
@@ -0,0 +1,42 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2013 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#ifndef _OXIDE_SHARED_BROWSER_MESSAGE_DISPATCHER_H_
+#define _OXIDE_SHARED_BROWSER_MESSAGE_DISPATCHER_H_
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "content/public/browser/browser_message_filter.h"
+
+namespace oxide {
+
+class MessageDispatcherBrowser FINAL : public content::BrowserMessageFilter {
+ public:
+  MessageDispatcherBrowser(int render_process_id);
+  ~MessageDispatcherBrowser();
+
+  bool OnMessageReceived(const IPC::Message& message,
+                         bool* message_was_ok) FINAL;
+ private:
+  const int render_process_id_;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(MessageDispatcherBrowser);
+};
+
+} // namespace oxide
+
+#endif // _OXIDE_SHARED_BROWSER_MESSAGE_DISPATCHER_H_

=== modified file 'shared/browser/oxide_message_handler.cc'
--- shared/browser/oxide_message_handler.cc	2013-11-20 19:02:08 +0000
+++ shared/browser/oxide_message_handler.cc	2014-02-07 16:51:32 +0000
@@ -18,14 +18,13 @@
 #include "oxide_message_handler.h"
 
 #include "base/logging.h"
-#include "content/public/browser/render_view_host.h"
-#include "content/public/browser/web_contents.h"
+#include "content/browser/frame_host/frame_tree_node.h"
+#include "content/public/browser/render_frame_host.h"
 
 #include "shared/common/oxide_messages.h"
 
 #include "oxide_incoming_message.h"
 #include "oxide_web_frame.h"
-#include "oxide_web_view.h"
 
 namespace oxide {
 
@@ -50,19 +49,15 @@
 
   if (error) {
     OxideMsg_SendMessage_Params params;
-    params.frame_id = message->source_frame()->identifier();
     params.world_id = message->world_id();
     params.serial = message->serial();
     params.type = OxideMsg_SendMessage_Type::Reply;
     params.error = OxideMsg_SendMessage_Error::UNCAUGHT_EXCEPTION;
-    params.args = error_desc;
+    params.payload = error_desc;
 
-    // FIXME: This is clearly broken for OOPIF
-    content::WebContents* web_contents =
-        message->source_frame()->view()->web_contents();
-    web_contents->Send(new OxideMsg_SendMessage(
-        web_contents->GetRenderViewHost()->GetRoutingID(),
-        params));
+    content::RenderFrameHost* rfh =
+        message->source_frame()->frame_tree_node()->current_frame_host();
+    rfh->Send(new OxideMsg_SendMessage(rfh->GetRoutingID(), params));
   }
 }
 

=== modified file 'shared/browser/oxide_outgoing_message_request.cc'
--- shared/browser/oxide_outgoing_message_request.cc	2013-11-20 19:02:08 +0000
+++ shared/browser/oxide_outgoing_message_request.cc	2014-02-07 16:51:32 +0000
@@ -38,7 +38,7 @@
 }
 
 void OutgoingMessageRequest::OnReceiveResponse(
-    const std::string& args,
+    const std::string& payload,
     OxideMsg_SendMessage_Error::Value error) {
   if (had_response_) {
     return;
@@ -48,11 +48,11 @@
 
   if (error != OxideMsg_SendMessage_Error::OK) {
     if (!error_callback_.is_null()) {
-      error_callback_.Run(error, args);
+      error_callback_.Run(error, payload);
     }
   } else {
     if (!reply_callback_.is_null()) {
-      reply_callback_.Run(args);
+      reply_callback_.Run(payload);
     }
   }
 }

=== modified file 'shared/browser/oxide_outgoing_message_request.h'
--- shared/browser/oxide_outgoing_message_request.h	2013-11-20 19:02:08 +0000
+++ shared/browser/oxide_outgoing_message_request.h	2014-02-07 16:51:32 +0000
@@ -47,7 +47,7 @@
   void SetReplyCallback(const ReplyCallback& callback);
   void SetErrorCallback(const ErrorCallback& callback);
 
-  void OnReceiveResponse(const std::string& args,
+  void OnReceiveResponse(const std::string& payload,
                          OxideMsg_SendMessage_Error::Value error);
 
  private:

=== modified file 'shared/browser/oxide_web_frame.cc'
--- shared/browser/oxide_web_frame.cc	2013-11-20 19:02:08 +0000
+++ shared/browser/oxide_web_frame.cc	2014-02-07 16:51:32 +0000
@@ -17,7 +17,12 @@
 
 #include "oxide_web_frame.h"
 
+#include <map>
+#include <utility>
+
+#include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "content/browser/frame_host/frame_tree_node.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 
@@ -28,21 +33,27 @@
 
 namespace oxide {
 
-void WebFrame::AddChildFrame(WebFrame* frame) {
-  DCHECK_NE(frame->identifier(), -1);
+namespace {
+typedef std::map<int64, WebFrame*> FrameMap;
+typedef FrameMap::iterator FrameMapIterator;
+base::LazyInstance<FrameMap> g_frame_map = LAZY_INSTANCE_INITIALIZER;
+}
 
+void WebFrame::AddChild(WebFrame* frame) {
   child_frames_.push_back(frame);
   OnChildAdded(frame);
+  view()->FrameAdded(frame);
 }
 
-void WebFrame::RemoveChildFrame(WebFrame* frame) {
+void WebFrame::RemoveChild(WebFrame* frame) {
   for (ChildVector::iterator it = child_frames_.begin();
        it != child_frames_.end(); ++it) {
     WebFrame* f = *it;
 
     if (f == frame) {
+      OnChildRemoved(frame);
+      view()->FrameRemoved(frame);
       child_frames_.erase(it);
-      OnChildRemoved(frame);
       return;
     }
   }
@@ -52,22 +63,33 @@
 void WebFrame::OnChildRemoved(WebFrame* child) {}
 void WebFrame::OnURLChanged() {}
 
-WebFrame::WebFrame() :
-    id_(-1),
+WebFrame::WebFrame(
+    content::FrameTreeNode* node,
+    WebView* view) :
+    frame_tree_node_(node),
     parent_(NULL),
-    view_(NULL),
+    view_(view),
     next_message_serial_(0),
-    destroyed_(false),
-    weak_factory_(this) {}
+    weak_factory_(this) {
+  std::pair<FrameMapIterator, bool> rv =
+      g_frame_map.Get().insert(std::make_pair(node->frame_tree_node_id(),
+                                              this));
+  CHECK(rv.second);
+}
 
 WebFrame::~WebFrame() {
-  DCHECK(destroyed_) <<
-      "WebFrame's destructor must only be called via DestroyFrame";
-}
-
-void WebFrame::DestroyFrame() {
+  g_frame_map.Get().erase(frame_tree_node_->frame_tree_node_id());
+}
+
+// static
+WebFrame* WebFrame::FromFrameTreeNode(content::FrameTreeNode* node) {
+  FrameMapIterator it = g_frame_map.Get().find(node->frame_tree_node_id());
+  return it == g_frame_map.Get().end() ? NULL : it->second;
+}
+
+void WebFrame::Destroy() {
   while (ChildCount() > 0) {
-    ChildAt(ChildCount() - 1)->DestroyFrame();
+    ChildAt(0)->Destroy();
   }
 
   while (true) {
@@ -86,19 +108,21 @@
 
     request->OnReceiveResponse(
         "The frame disappeared whilst waiting for a response",
-        OxideMsg_SendMessage_Error::FRAME_DISAPPEARED);
+        OxideMsg_SendMessage_Error::INVALID_DESTINATION);
   }
 
   if (parent_) {
-    parent_->RemoveChildFrame(this);
+    parent_->RemoveChild(this);
     parent_ = NULL;
   }
 
-  destroyed_ = true;
-
   delete this;
 }
 
+int64 WebFrame::FrameTreeNodeID() const {
+  return frame_tree_node()->frame_tree_node_id();
+}
+
 void WebFrame::SetURL(const GURL& url) {
   url_ = url;
   OnURLChanged();
@@ -107,7 +131,7 @@
 void WebFrame::SetParent(WebFrame* parent) {
   DCHECK(!parent_) << "Changing parents is not supported";
   parent_ = parent;
-  parent_->AddChildFrame(this);
+  parent_->AddChild(this);
 }
 
 size_t WebFrame::ChildCount() const {
@@ -122,17 +146,9 @@
   return child_frames_.at(index);
 }
 
-void WebFrame::AddChildrenToQueue(std::queue<WebFrame *>* queue) const {
-  for (ChildVector::const_iterator it = child_frames_.begin();
-       it != child_frames_.end(); ++it) {
-    WebFrame* frame = *it;
-    queue->push(frame);
-  }
-}
-
 bool WebFrame::SendMessage(const std::string& world_id,
                            const std::string& msg_id,
-                           const std::string& args,
+                           const std::string& payload,
                            OutgoingMessageRequest* req) {
   DCHECK(req);
 
@@ -141,36 +157,28 @@
   req->set_serial(serial);
 
   OxideMsg_SendMessage_Params params;
-  params.frame_id = identifier();
   params.world_id = world_id;
   params.serial = serial;
   params.type = OxideMsg_SendMessage_Type::Message;
   params.msg_id = msg_id;
-  params.args = args;
+  params.payload = payload;
 
-  // FIXME: This is clearly broken for OOPIF
-  content::WebContents* web_contents = view()->web_contents();
-  return web_contents->Send(new OxideMsg_SendMessage(
-      web_contents->GetRenderViewHost()->GetRoutingID(),
-      params));
+  content::RenderFrameHost* rfh = frame_tree_node()->current_frame_host();
+  return rfh->Send(new OxideMsg_SendMessage(rfh->GetRoutingID(), params));
 }
 
 bool WebFrame::SendMessageNoReply(const std::string& world_id,
                                   const std::string& msg_id,
-                                  const std::string& args) {
+                                  const std::string& payload) {
   OxideMsg_SendMessage_Params params;
-  params.frame_id = identifier();
   params.world_id = world_id;
   params.serial = -1;
   params.type = OxideMsg_SendMessage_Type::Message;
   params.msg_id = msg_id;
-  params.args = args;
+  params.payload = payload;
 
-  // FIXME: This is clearly broken for OOPIF
-  content::WebContents* web_contents = view()->web_contents();
-  return web_contents->Send(new OxideMsg_SendMessage(
-      web_contents->GetRenderViewHost()->GetRoutingID(),
-      params));
+  content::RenderFrameHost* rfh = frame_tree_node()->current_frame_host();
+  return rfh->Send(new OxideMsg_SendMessage(rfh->GetRoutingID(), params));
 }
 
 size_t WebFrame::GetMessageHandlerCount() const {

=== modified file 'shared/browser/oxide_web_frame.h'
--- shared/browser/oxide_web_frame.h	2013-11-20 19:02:08 +0000
+++ shared/browser/oxide_web_frame.h	2014-02-07 16:51:32 +0000
@@ -23,10 +23,15 @@
 
 #include "base/basictypes.h"
 #include "base/memory/weak_ptr.h"
+#include "ipc/ipc_sender.h"
 #include "url/gurl.h"
 
 #include "shared/browser/oxide_message_target.h"
 
+namespace content {
+class FrameTreeNode;
+}
+
 namespace oxide {
 
 class OutgoingMessageRequest;
@@ -37,17 +42,11 @@
 // of this will typically own a publicly exposed webframe
 class WebFrame : public MessageTarget {
  public:
-  // Use this to delete a WebFrame rather than calling the destructor, so
-  // that we can remove the frame from its parent before the derived destructor
-  // is called
-  void DestroyFrame();
-
-  int64 identifier() const {
-    return id_;
-  }
-  void set_identifier(int64 id) {
-    id_ = id;
-  }
+  static WebFrame* FromFrameTreeNode(content::FrameTreeNode* node);
+
+  void Destroy();
+
+  int64 FrameTreeNodeID() const;
 
   GURL url() const {
     return url_;
@@ -60,29 +59,28 @@
   WebView* view() const {
     return view_;
   }
-  void set_view(WebView* view) {
-    view_ = view;
-  }
 
   base::WeakPtr<WebFrame> GetWeakPtr() {
     return weak_factory_.GetWeakPtr();
   }
 
+  content::FrameTreeNode* frame_tree_node() const {
+    return frame_tree_node_;
+  }
+
   void SetURL(const GURL& url);
   void SetParent(WebFrame* parent);
 
   size_t ChildCount() const;
   WebFrame* ChildAt(size_t index) const;
 
-  void AddChildrenToQueue(std::queue<WebFrame *>* queue) const;
-
   bool SendMessage(const std::string& world_id,
                    const std::string& msg_id,
-                   const std::string& args,
+                   const std::string& payload,
                    OutgoingMessageRequest* req);
   bool SendMessageNoReply(const std::string& world_id,
                           const std::string& msg_id,
-                          const std::string& args);
+                          const std::string& payload);
 
   virtual size_t GetMessageHandlerCount() const OVERRIDE;
   virtual MessageHandler* GetMessageHandlerAt(size_t index) const OVERRIDE;
@@ -91,26 +89,25 @@
   virtual OutgoingMessageRequest* GetOutgoingMessageRequestAt(size_t index) const;
 
  protected:
-  WebFrame();
+  WebFrame(content::FrameTreeNode* node, WebView* view);
   virtual ~WebFrame();
 
  private:
   typedef std::vector<WebFrame *> ChildVector;
 
-  void AddChildFrame(WebFrame* frame);
-  void RemoveChildFrame(WebFrame* frame);
+  void AddChild(WebFrame* frame);
+  void RemoveChild(WebFrame* frame);
 
   virtual void OnChildAdded(WebFrame* child);
   virtual void OnChildRemoved(WebFrame* child);
   virtual void OnURLChanged();
 
-  int64 id_;
+  content::FrameTreeNode* frame_tree_node_;
   GURL url_;
   ChildVector child_frames_;
   WebFrame* parent_;
   WebView* view_;
   int next_message_serial_;
-  bool destroyed_;
   base::WeakPtrFactory<WebFrame> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WebFrame);

=== added file 'shared/browser/oxide_web_preferences.cc'
--- shared/browser/oxide_web_preferences.cc	1970-01-01 00:00:00 +0000
+++ shared/browser/oxide_web_preferences.cc	2014-02-07 16:51:32 +0000
@@ -0,0 +1,271 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2013 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#include "oxide_web_preferences.h"
+
+#include "base/logging.h"
+#include "base/strings/utf_string_conversions.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/web_contents.h"
+#include "ui/gl/gl_context.h"
+#include "ui/gl/gl_implementation.h"
+#include "ui/gl/gl_share_group.h"
+#include "webkit/common/webpreferences.h"
+
+#include "shared/common/oxide_content_client.h"
+#include "shared/gl/oxide_shared_gl_context.h"
+
+#include "oxide_content_browser_client.h"
+#include "oxide_web_view.h"
+
+namespace oxide {
+
+namespace {
+
+bool SupportsCompositing() {
+  gfx::GLShareGroup* group =
+      ContentClient::instance()->browser()->GetGLShareGroup();
+  if (!group) {
+    return false;
+  }
+
+  SharedGLContext* context = SharedGLContext::FromGfx(group->GetContext());
+  if (!context) {
+    return false;
+  }
+
+  return context->GetImplementation() == gfx::GetGLImplementation();
+}
+
+} // namespace
+
+void WebPreferences::UpdateViews() {
+  for (std::set<WebView *>::const_iterator it = views_.begin();
+       it != views_.end(); ++it) {
+    WebView* view = *it;
+    content::WebContents* contents = view->web_contents();
+    if (!contents) {
+      continue;
+    }
+    contents->GetRenderViewHost()->UpdateWebkitPreferences(
+        contents->GetRenderViewHost()->GetWebkitPreferences());
+  }
+}
+
+WebPreferences::WebPreferences() :
+    standard_font_family_(base::UTF8ToUTF16("Times New Roman")),
+    fixed_font_family_(base::UTF8ToUTF16("Courier New")),
+    serif_font_family_(base::UTF8ToUTF16("Times New Roman")),
+    sans_serif_font_family_(base::UTF8ToUTF16("Arial")),
+    default_encoding_("ISO-8859-1"),
+    default_font_size_(16),
+    default_fixed_font_size_(13),
+    minimum_font_size_(0) {
+  for (unsigned int i = 0; i < ATTR_LAST; ++i) {
+    attributes_[i] = false;
+  }
+
+  SetAttribute(ATTR_REMOTE_FONTS_ENABLED, true);
+  SetAttribute(ATTR_JAVASCRIPT_ENABLED, true);
+  SetAttribute(ATTR_WEB_SECURITY_ENABLED, true);
+  SetAttribute(ATTR_POPUP_BLOCKER_ENABLED, true);
+
+  // ATTR_ALLOW_SCRIPTS_TO_CLOSE_WINDOWS
+  // ATTR_JAVASCRIPT_CAN_ACCESS_CLIPBOARD
+
+  SetAttribute(ATTR_HYPERLINK_AUDITING_ENABLED, true);
+
+  // ATTR_ALLOW_UNIVERSAL_ACCESS_FROM_FILE_URLS
+  // ATTR_ALLOW_FILE_ACCESS_FROM_FILE_URLS
+  // ATTR_CAN_DISPLAY_INSECURE_CONTENT
+  // ATTR_CAN_RUN_INSECURE_CONTENT
+  // ATTR_PASSWORD_ECHO_ENABLED
+
+  SetAttribute(ATTR_LOADS_IMAGES_AUTOMATICALLY, true);
+  SetAttribute(ATTR_SHRINKS_STANDALONE_IMAGES_TO_FIT, true);
+
+  SetAttribute(ATTR_TEXT_AREAS_ARE_RESIZABLE, true);
+
+  // ATTR_LOCAL_STORAGE_ENABLED
+  // ATTR_DATABASES_ENABLED
+  // ATTR_APP_CACHE_ENABLED
+  // ATTR_FULLSCREEN_ENABLED
+
+  SetAttribute(ATTR_TABS_TO_LINKS, true);
+
+  // ATTR_CARET_BROWSING_ENABLED
+
+  SetAttribute(ATTR_ACCELERATED_COMPOSITING_ENABLED, true);
+  SetAttribute(ATTR_SMOOTH_SCROLLING_ENABLED, true);
+
+  // ATTR_TOUCH_ENABLED
+  // ATTR_SUPPORTS_MULTIPLE_WINDOWS
+  // ATTR_VIEWPORT_ENABLED
+}
+
+WebPreferences::~WebPreferences() {
+  CHECK(views_.empty());
+}
+
+std::string WebPreferences::StandardFontFamily() const {
+  return base::UTF16ToUTF8(standard_font_family_);
+}
+
+void WebPreferences::SetStandardFontFamily(const std::string& font) {
+  standard_font_family_ = base::UTF8ToUTF16(font);
+  UpdateViews();
+}
+
+std::string WebPreferences::FixedFontFamily() const {
+  return base::UTF16ToUTF8(fixed_font_family_);
+}
+
+void WebPreferences::SetFixedFontFamily(const std::string& font) {
+  fixed_font_family_ = base::UTF8ToUTF16(font);
+  UpdateViews();
+}
+
+std::string WebPreferences::SerifFontFamily() const {
+  return base::UTF16ToUTF8(serif_font_family_);
+}
+
+void WebPreferences::SetSerifFontFamily(const std::string& font) {
+  serif_font_family_ = base::UTF8ToUTF16(font);
+  UpdateViews();
+}
+
+std::string WebPreferences::SansSerifFontFamily() const {
+  return base::UTF16ToUTF8(sans_serif_font_family_);
+}
+
+void WebPreferences::SetSansSerifFontFamily(const std::string& font) {
+  sans_serif_font_family_ = base::UTF8ToUTF16(font);
+  UpdateViews();
+}
+
+void WebPreferences::SetDefaultEncoding(const std::string& encoding) {
+  default_encoding_ = encoding;
+  UpdateViews();
+}
+
+void WebPreferences::SetDefaultFontSize(unsigned size) {
+  default_font_size_ = size;
+  UpdateViews();
+}
+
+void WebPreferences::SetDefaultFixedFontSize(unsigned size) {
+  default_fixed_font_size_ = size;
+  UpdateViews();
+}
+
+void WebPreferences::SetMinimumFontSize(unsigned size) {
+  minimum_font_size_ = size;
+  UpdateViews();
+}
+
+bool WebPreferences::TestAttribute(Attr attr) const {
+  DCHECK(attr < ATTR_LAST && attr >= 0);
+  return attributes_[attr];
+}
+
+void WebPreferences::SetAttribute(Attr attr, bool val) {
+  DCHECK(attr < ATTR_LAST && attr >= 0);
+  attributes_[attr] = val;
+  UpdateViews();
+}
+
+void WebPreferences::AddWebView(WebView* view) {
+  views_.insert(view);
+}
+
+void WebPreferences::RemoveWebView(WebView* view) {
+  views_.erase(view);
+}
+
+void WebPreferences::ApplyToWebkitPrefs(::WebPreferences* prefs) {
+  prefs->standard_font_family_map[webkit_glue::kCommonScript] =
+      standard_font_family_;
+  prefs->fixed_font_family_map[webkit_glue::kCommonScript] =
+      fixed_font_family_;
+  prefs->serif_font_family_map[webkit_glue::kCommonScript] =
+      serif_font_family_;
+  prefs->sans_serif_font_family_map[webkit_glue::kCommonScript] =
+      sans_serif_font_family_;
+
+  prefs->default_encoding = default_encoding_;
+
+  prefs->default_font_size = default_font_size_;
+  prefs->default_fixed_font_size = default_fixed_font_size_;
+  prefs->minimum_font_size = minimum_font_size_;
+
+  prefs->remote_fonts_enabled = attributes_[ATTR_REMOTE_FONTS_ENABLED];
+
+  prefs->javascript_enabled = attributes_[ATTR_JAVASCRIPT_ENABLED];
+  prefs->web_security_enabled = attributes_[ATTR_WEB_SECURITY_ENABLED];
+  prefs->javascript_can_open_windows_automatically =
+      !attributes_[ATTR_POPUP_BLOCKER_ENABLED];
+  prefs->allow_scripts_to_close_windows =
+      attributes_[ATTR_ALLOW_SCRIPTS_TO_CLOSE_WINDOWS];
+  prefs->javascript_can_access_clipboard =
+      attributes_[ATTR_JAVASCRIPT_CAN_ACCESS_CLIPBOARD];
+
+  prefs->hyperlink_auditing_enabled =
+      attributes_[ATTR_HYPERLINK_AUDITING_ENABLED];
+  prefs->allow_universal_access_from_file_urls =
+      attributes_[ATTR_ALLOW_UNIVERSAL_ACCESS_FROM_FILE_URLS];
+  prefs->allow_file_access_from_file_urls =
+      attributes_[ATTR_ALLOW_FILE_ACCESS_FROM_FILE_URLS];
+  prefs->allow_displaying_insecure_content =
+      attributes_[ATTR_CAN_DISPLAY_INSECURE_CONTENT];
+  prefs->allow_running_insecure_content =
+      attributes_[ATTR_CAN_RUN_INSECURE_CONTENT];
+  prefs->password_echo_enabled = attributes_[ATTR_PASSWORD_ECHO_ENABLED];
+
+  prefs->loads_images_automatically =
+      attributes_[ATTR_LOADS_IMAGES_AUTOMATICALLY];
+  prefs->shrinks_standalone_images_to_fit =
+      attributes_[ATTR_SHRINKS_STANDALONE_IMAGES_TO_FIT];
+
+  prefs->text_areas_are_resizable = attributes_[ATTR_TEXT_AREAS_ARE_RESIZABLE];
+
+  prefs->local_storage_enabled = attributes_[ATTR_LOCAL_STORAGE_ENABLED];
+  prefs->databases_enabled = attributes_[ATTR_DATABASES_ENABLED];
+  prefs->application_cache_enabled = attributes_[ATTR_APP_CACHE_ENABLED];
+  prefs->fullscreen_enabled = attributes_[ATTR_FULLSCREEN_ENABLED];
+
+  prefs->tabs_to_links = attributes_[ATTR_TABS_TO_LINKS];
+  prefs->caret_browsing_enabled = attributes_[ATTR_CARET_BROWSING_ENABLED];
+
+  bool compositing =
+      attributes_[ATTR_ACCELERATED_COMPOSITING_ENABLED] &&
+      SupportsCompositing();
+  prefs->accelerated_compositing_enabled = compositing;
+  prefs->force_compositing_mode = compositing;
+
+  prefs->enable_scroll_animator = attributes_[ATTR_SMOOTH_SCROLLING_ENABLED];
+
+  prefs->touch_enabled = false; // TODO: Check if touch is supported
+
+  prefs->supports_multiple_windows = attributes_[ATTR_SUPPORTS_MULTIPLE_WINDOWS];
+
+  // Viewport only works in compositing mode
+  prefs->viewport_enabled = attributes_[ATTR_VIEWPORT_ENABLED] && compositing;
+  // XXX: Should this be a separate pref?
+  prefs->viewport_meta_enabled = prefs->viewport_enabled;
+}
+
+} // namespace oxide

=== added file 'shared/browser/oxide_web_preferences.h'
--- shared/browser/oxide_web_preferences.h	1970-01-01 00:00:00 +0000
+++ shared/browser/oxide_web_preferences.h	2014-02-07 16:51:32 +0000
@@ -0,0 +1,138 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2013 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#ifndef _OXIDE_SHARED_BROWSER_WEB_PREFERENCES_H_
+#define _OXIDE_SHARED_BROWSER_WEB_PREFERENCES_H_
+
+#include <set>
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/strings/string16.h"
+
+class WebPreferences;
+
+namespace oxide {
+
+class WebView;
+
+class WebPreferences {
+ public:
+  WebPreferences();
+  virtual ~WebPreferences();
+
+  enum Attr {
+    ATTR_REMOTE_FONTS_ENABLED,
+
+    ATTR_JAVASCRIPT_ENABLED,
+    ATTR_WEB_SECURITY_ENABLED,
+    ATTR_POPUP_BLOCKER_ENABLED,
+    ATTR_ALLOW_SCRIPTS_TO_CLOSE_WINDOWS,
+    ATTR_JAVASCRIPT_CAN_ACCESS_CLIPBOARD,
+
+    ATTR_HYPERLINK_AUDITING_ENABLED, // enables anchor ping
+    ATTR_ALLOW_UNIVERSAL_ACCESS_FROM_FILE_URLS,
+    ATTR_ALLOW_FILE_ACCESS_FROM_FILE_URLS,
+    ATTR_CAN_DISPLAY_INSECURE_CONTENT, // Passive mixed-content blocking
+    ATTR_CAN_RUN_INSECURE_CONTENT, // Active mixed-content blocking
+    ATTR_PASSWORD_ECHO_ENABLED,
+
+    ATTR_LOADS_IMAGES_AUTOMATICALLY,
+    ATTR_SHRINKS_STANDALONE_IMAGES_TO_FIT,
+
+    ATTR_TEXT_AREAS_ARE_RESIZABLE,
+
+    ATTR_LOCAL_STORAGE_ENABLED,
+    ATTR_DATABASES_ENABLED,
+    ATTR_APP_CACHE_ENABLED,
+    ATTR_FULLSCREEN_ENABLED,
+
+    ATTR_TABS_TO_LINKS, // whether pressing |TAB\ focuses links
+    ATTR_CARET_BROWSING_ENABLED,
+
+    ATTR_ACCELERATED_COMPOSITING_ENABLED,
+    ATTR_SMOOTH_SCROLLING_ENABLED,
+    ATTR_TOUCH_ENABLED,
+    ATTR_SUPPORTS_MULTIPLE_WINDOWS,
+    ATTR_VIEWPORT_ENABLED,
+
+    ATTR_LAST
+  };
+
+  std::string StandardFontFamily() const;
+  void SetStandardFontFamily(const std::string& font);
+
+  std::string FixedFontFamily() const;
+  void SetFixedFontFamily(const std::string& font);
+
+  std::string SerifFontFamily() const;
+  void SetSerifFontFamily(const std::string& font);
+
+  std::string SansSerifFontFamily() const;
+  void SetSansSerifFontFamily(const std::string& font);
+
+  std::string default_encoding() const {
+    return default_encoding_;
+  }
+  void SetDefaultEncoding(const std::string& encoding);
+
+  unsigned default_font_size() const {
+    return default_font_size_;
+  }
+  void SetDefaultFontSize(unsigned size);
+
+  unsigned default_fixed_font_size() const {
+    return default_fixed_font_size_;
+  }
+  void SetDefaultFixedFontSize(unsigned size);
+
+  unsigned minimum_font_size() const {
+    return minimum_font_size_;
+  }
+  void SetMinimumFontSize(unsigned size);
+
+  bool TestAttribute(Attr attr) const;
+  void SetAttribute(Attr attr, bool val);
+
+  void AddWebView(WebView* view);
+  void RemoveWebView(WebView* view);
+
+  void ApplyToWebkitPrefs(::WebPreferences* prefs);
+
+ private:
+  void UpdateViews();
+
+  base::string16 standard_font_family_;
+  base::string16 fixed_font_family_;
+  base::string16 serif_font_family_;
+  base::string16 sans_serif_font_family_;
+  std::string default_encoding_;
+  unsigned default_font_size_;
+  unsigned default_fixed_font_size_;
+  unsigned minimum_font_size_;
+
+  bool attributes_[ATTR_LAST];
+
+  std::set<WebView *> views_;
+
+  DISALLOW_COPY_AND_ASSIGN(WebPreferences);
+};
+
+} // namespace oxide
+
+#endif // _OXIDE_SHARED_BROWSER_WEB_PREFERENCES_H_

=== modified file 'shared/browser/oxide_web_view.cc'
--- shared/browser/oxide_web_view.cc	2014-01-20 12:35:23 +0000
+++ shared/browser/oxide_web_view.cc	2014-02-07 16:51:32 +0000
@@ -21,7 +21,10 @@
 
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
+#include "content/browser/frame_host/frame_tree.h"
+#include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
+#include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/invalidate_type.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/navigation_controller.h"
@@ -32,22 +35,21 @@
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
+#include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "net/base/net_errors.h"
 #include "url/gurl.h"
+#include "webkit/common/webpreferences.h"
 
 #include "shared/common/oxide_content_client.h"
-#include "shared/common/oxide_messages.h"
 
 #include "oxide_browser_context.h"
 #include "oxide_browser_process_main.h"
 #include "oxide_content_browser_client.h"
-#include "oxide_incoming_message.h"
-#include "oxide_message_handler.h"
-#include "oxide_outgoing_message_request.h"
 #include "oxide_web_contents_view.h"
 #include "oxide_web_frame.h"
+#include "oxide_web_preferences.h"
 
 namespace oxide {
 
@@ -87,123 +89,12 @@
   }
 }
 
-void WebView::SendErrorForV8Message(long long frame_id,
-                                    const std::string& world_id,
-                                    int serial,
-                                    OxideMsg_SendMessage_Error::Value error_code,
-                                    const std::string& error_desc) {
-  OxideMsg_SendMessage_Params params;
-  params.frame_id = frame_id;
-  params.world_id = world_id;
-  params.serial = serial;
-  params.type = OxideMsg_SendMessage_Type::Reply;
-  params.error = error_code;
-  params.args = error_desc;
-
-  // FIXME: This is clearly broken for OOPIF, and we don't even know if this
-  //        is going to the correct RVH without OOPIF
-  web_contents()->Send(new OxideMsg_SendMessage(
-      web_contents()->GetRenderViewHost()->GetRoutingID(),
-      params));
-}
-
-bool WebView::TryDispatchV8MessageToTarget(MessageTarget* target,
-                                           WebFrame* source_frame,
-                                           const std::string& world_id,
-                                           int serial,
-                                           const std::string& msg_id,
-                                           const std::string& args) {
-  for (size_t i = 0; i < target->GetMessageHandlerCount(); ++i) {
-    MessageHandler* handler = target->GetMessageHandlerAt(i);
-
-    if (!handler->IsValid()) {
-      continue;
-    }
-
-    if (handler->msg_id() != msg_id) {
-      continue;
-    }
-
-    const std::vector<std::string>& world_ids = handler->world_ids();
-
-    for (std::vector<std::string>::const_iterator it = world_ids.begin();
-         it != world_ids.end(); ++it) {
-      if ((*it) == world_id) {
-        handler->OnReceiveMessage(
-            new IncomingMessage(source_frame, serial, world_id,
-                                msg_id, args));
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-void WebView::DispatchV8Message(const OxideMsg_SendMessage_Params& params) {
-  WebFrame* frame = FindFrameWithID(params.frame_id);
-
-  if (params.type == OxideMsg_SendMessage_Type::Message) {
-    if (!frame) {
-      // FIXME: In an OOPIF world, how do we know which process to dispatch
-      //        this error too, if we couldn't find a frame?
-      SendErrorForV8Message(params.frame_id, params.world_id, params.serial,
-                            OxideMsg_SendMessage_Error::INVALID_DESTINATION,
-                            "Invalid frame ID");
-      return;
-    }
-
-    if (!TryDispatchV8MessageToTarget(frame, frame, params.world_id,
-                                      params.serial, params.msg_id,
-                                      params.args)) {
-      if (!TryDispatchV8MessageToTarget(this, frame, params.world_id,
-                                        params.serial, params.msg_id,
-                                        params.args)) {
-        SendErrorForV8Message(params.frame_id, params.world_id, params.serial,
-                              OxideMsg_SendMessage_Error::NO_HANDLER,
-                              "No handler was found for message");
-      }
-    }
-
-    return;
-  }
-
-  if (!frame) {
-    return;
-  }
-
-  for (size_t i = 0; i < frame->GetOutgoingMessageRequestCount(); ++i) {
-    OutgoingMessageRequest* request = frame->GetOutgoingMessageRequestAt(i);
-
-    if (request->serial() == params.serial) {
-      request->OnReceiveResponse(params.args, params.error);
-      return;
-    }
-  }
-}
-
-void WebView::OnFrameCreated(int64 parent_frame_id,
-                             int64 frame_id) {
-  WebFrame* parent = FindFrameWithID(parent_frame_id);
-  if (!parent) {
-    LOG(ERROR) << "Got FrameCreated with non-existant parent";
-    return;
-  }
-
-  WebFrame* frame = CreateWebFrame();
-  frame->set_identifier(frame_id);
-  frame->set_view(this);
-  frame->SetParent(parent);
-}
-
 void WebView::OnURLChanged() {}
 void WebView::OnTitleChanged() {}
 void WebView::OnCommandsUpdated() {}
 
 void WebView::OnLoadProgressChanged(double progress) {}
 
-void WebView::OnRootFrameChanged() {}
-
 void WebView::OnLoadStarted(const GURL& validated_url,
                             bool is_error_frame) {}
 void WebView::OnLoadStopped(const GURL& validated_url) {}
@@ -217,9 +108,14 @@
 void WebView::OnNavigationEntryChanged(int index) {}
 
 WebView::WebView() :
-    root_frame_(NULL) {}
+    root_frame_(NULL),
+    web_preferences_(NULL) {}
 
 WebView::~WebView() {
+  if (web_preferences_) {
+    web_preferences_->RemoveWebView(this);
+  }
+
   if (web_contents_) {
     GetBrowserContext()->RemoveWebView(this);
     web_contents_->SetDelegate(NULL);
@@ -244,7 +140,8 @@
 
   content::WebContents::CreateParams params(context);
   params.initial_size = initial_size;
-  web_contents_.reset(content::WebContents::Create(params));
+  web_contents_.reset(static_cast<content::WebContentsImpl *>(
+      content::WebContents::Create(params)));
   if (!web_contents_) {
     LOG(ERROR) << "Failed to create WebContents";
     return false;
@@ -259,6 +156,8 @@
   registrar_->Add(this, content::NOTIFICATION_NAV_ENTRY_CHANGED,
                   content::NotificationService::AllBrowserContextsAndSources());
 
+  root_frame_ = CreateWebFrame(web_contents_->GetFrameTree()->root());
+
   return true;
 }
 
@@ -272,10 +171,8 @@
 
   WebContentsObserver::Observe(NULL);
 
-  if (root_frame_) {
-    root_frame_->DestroyFrame();
-    root_frame_ = NULL;
-  }
+  root_frame_->Destroy();
+  root_frame_ = NULL;
 
   GetBrowserContext()->RemoveWebView(this);
   web_contents_.reset();
@@ -382,6 +279,10 @@
   return BrowserContext::FromContent(web_contents_->GetBrowserContext());
 }
 
+content::WebContents* WebView::GetWebContents() const {
+  return web_contents_.get();
+}
+
 int WebView::GetNavigationEntryCount() const {
   if (!web_contents_) {
     return 0;
@@ -442,11 +343,7 @@
   return root_frame_;
 }
 
-WebFrame* WebView::FindFrameWithID(int64 frame_id) const {
-  if (!root_frame_) {
-    return NULL;
-  }
-
+WebFrame* WebView::FindFrameWithID(int64 frame_tree_node_id) const {
   std::queue<WebFrame *> q;
   q.push(const_cast<WebFrame *>(root_frame_));
 
@@ -454,20 +351,51 @@
     WebFrame* f = q.front();
     q.pop();
 
-    if (f->identifier() == frame_id) {
+    if (f->FrameTreeNodeID() == frame_tree_node_id) {
       return f;
     }
 
-    f->AddChildrenToQueue(&q);
+    for (size_t i = 0; i < f->ChildCount(); ++i) {
+      q.push(f->ChildAt(i));
+    }
   }
 
   return NULL;
 }
 
+WebPreferences* WebView::GetWebPreferences() {
+  if (!web_preferences_) {
+    SetWebPreferences(
+        ContentClient::instance()->browser()->GetDefaultWebPreferences(),
+        false);
+  }
+
+  return web_preferences_;
+}
+
+void WebView::SetWebPreferences(WebPreferences* prefs, bool send_update) {
+  if (web_preferences_) {
+    web_preferences_->RemoveWebView(this);
+  }
+
+  web_preferences_ = prefs;
+  if (prefs) {
+    prefs->AddWebView(this);
+  }
+
+  if (!send_update || !web_contents_) {
+    return;
+  }
+
+  web_contents()->GetRenderViewHost()->UpdateWebkitPreferences(
+      web_contents()->GetRenderViewHost()->GetWebkitPreferences());
+}
+
 void WebView::Observe(int type,
                       const content::NotificationSource& source,
                       const content::NotificationDetails& details) {
-  if (content::Source<content::NavigationController>(source).ptr() != &web_contents()->GetController()) {
+  if (content::Source<content::NavigationController>(source).ptr() !=
+      &GetWebContents()->GetController()) {
     return;
   }
   if (type == content::NOTIFICATION_NAV_LIST_PRUNED) {
@@ -482,21 +410,12 @@
 void WebView::RenderViewHostChanged(content::RenderViewHost* old_host,
                                     content::RenderViewHost* new_host) {
   // Make sure the new RWHV gets the correct size
-  web_contents()->GetView()->SizeContents(
-      web_contents()->GetView()->GetContainerSize());
-
-  if (root_frame_) {
-    root_frame_->DestroyFrame();
-  }
-
-  if (new_host) {
-    root_frame_ = CreateWebFrame();
-    root_frame_->set_view(this);
-  } else {
-    root_frame_ = NULL;
-  }
-
-  OnRootFrameChanged();
+  GetWebContents()->GetView()->SizeContents(
+      GetWebContents()->GetView()->GetContainerSize());
+
+  while (root_frame_->ChildCount() > 0) {
+    root_frame_->ChildAt(0)->Destroy();
+  }
 }
 
 void WebView::DidStartProvisionalLoadForFrame(
@@ -521,11 +440,11 @@
     const GURL& url,
     content::PageTransition transition_type,
     content::RenderViewHost* render_view_host) {
-  if (is_main_frame) {
-    root_frame_->set_identifier(frame_id);
-  }
+  content::FrameTreeNode* node =
+      web_contents_->GetFrameTree()->FindByFrameID(frame_id);
+  DCHECK(node);
 
-  WebFrame* frame = FindFrameWithID(frame_id);
+  WebFrame* frame = FindFrameWithID(node->frame_tree_node_id());
   if (frame) {
     frame->SetURL(url);
   }
@@ -577,12 +496,43 @@
 
 void WebView::FrameDetached(content::RenderViewHost* rvh,
                             int64 frame_id) {
-  WebFrame* frame = FindFrameWithID(frame_id);
-  if (!frame) {
-    return;
-  }
-
-  frame->DestroyFrame();
+  if (!root_frame_) {
+    return;
+  }
+
+  // XXX: This is temporary until there's a better API for these events
+  //      The ID we have is only renderer-process unique
+  content::FrameTreeNode* node =
+      web_contents_->GetFrameTree()->FindByFrameID(frame_id);
+  DCHECK(node);
+
+  WebFrame* frame = FindFrameWithID(node->frame_tree_node_id());
+  DCHECK(frame);
+
+  frame->Destroy();
+}
+
+void WebView::FrameAttached(content::RenderViewHost* rvh,
+                            int64 parent_frame_id,
+                            int64 frame_id) {
+  if (!root_frame_) {
+    return;
+  }
+
+  // XXX: This is temporary until there's a better API for these events
+  //      The ID's we have are only renderer-process unique
+  content::FrameTree* tree = web_contents_->GetFrameTree();
+  content::FrameTreeNode* parent_node = tree->FindByFrameID(parent_frame_id);
+  content::FrameTreeNode* node = tree->FindByFrameID(frame_id);
+
+  DCHECK(parent_node && node);
+
+  WebFrame* parent = FindFrameWithID(parent_node->frame_tree_node_id());
+  DCHECK(parent);
+
+  WebFrame* frame = CreateWebFrame(node);
+  DCHECK(frame);
+  frame->SetParent(parent);
 }
 
 void WebView::TitleWasSet(content::NavigationEntry* entry, bool explicit_set) {
@@ -599,17 +549,6 @@
   }
 }
 
-bool WebView::OnMessageReceived(const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(WebView, message)
-    IPC_MESSAGE_HANDLER(OxideHostMsg_SendMessage, DispatchV8Message)
-    IPC_MESSAGE_HANDLER(OxideHostMsg_FrameCreated, OnFrameCreated)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-
-  return handled;
-}
-
 size_t WebView::GetMessageHandlerCount() const {
   return 0;
 }
@@ -622,4 +561,7 @@
   return NULL;
 }
 
+void WebView::FrameAdded(WebFrame* frame) {}
+void WebView::FrameRemoved(WebFrame* frame) {}
+
 } // namespace oxide

=== modified file 'shared/browser/oxide_web_view.h'
--- shared/browser/oxide_web_view.h	2014-01-20 12:35:23 +0000
+++ shared/browser/oxide_web_view.h	2014-02-07 16:51:32 +0000
@@ -32,8 +32,6 @@
 #include "shared/browser/oxide_message_target.h"
 #include "shared/common/oxide_message_enums.h"
 
-struct OxideMsg_SendMessage_Params;
-
 class GURL;
 
 namespace gfx {
@@ -42,11 +40,13 @@
 
 namespace content {
 
+class FrameTreeNode;
 class NotificationRegistrar;
 struct OpenURLParams;
 class RenderWidgetHost;
 class RenderWidgetHostView;
 class WebContents;
+class WebContentsImpl;
 
 } // namespace content
 
@@ -55,6 +55,7 @@
 class BrowserContext;
 class WebFrame;
 class WebPopupMenu;
+class WebPreferences;
 
 // This is the main webview class. Implementations should subclass
 // this. Note that this class will hold the main browser process
@@ -96,6 +97,7 @@
   void Hidden();
 
   BrowserContext* GetBrowserContext() const;
+  content::WebContents* GetWebContents() const;
 
   int GetNavigationEntryCount() const;
   int GetNavigationCurrentEntryIndex() const;
@@ -106,7 +108,10 @@
   base::Time GetNavigationEntryTimestamp(int index) const;
 
   WebFrame* GetRootFrame() const;
-  WebFrame* FindFrameWithID(int64 frame_id) const;
+  WebFrame* FindFrameWithID(int64 frame_tree_node_id) const;
+
+  WebPreferences* GetWebPreferences();
+  void SetWebPreferences(WebPreferences* prefs, bool send_update = true);
 
   void Observe(int type,
                const content::NotificationSource& source,
@@ -157,18 +162,14 @@
 
   void FrameDetached(content::RenderViewHost* rvh,
                      int64 frame_id) FINAL;
+  void FrameAttached(content::RenderViewHost* rvh,
+                     int64 parent_frame_id, int64 frame_id) FINAL;
 
   void TitleWasSet(content::NavigationEntry* entry, bool explicit_set) FINAL;
 
-  bool OnMessageReceived(const IPC::Message& message) FINAL;
-
   virtual size_t GetMessageHandlerCount() const OVERRIDE;
   virtual MessageHandler* GetMessageHandlerAt(size_t index) const OVERRIDE;
 
-  content::WebContents* web_contents() const {
-    return web_contents_.get();
-  }
-
   virtual content::RenderWidgetHostView* CreateViewForWidget(
       content::RenderWidgetHost* render_widget_host) = 0;
 
@@ -176,6 +177,9 @@
 
   virtual WebPopupMenu* CreatePopupMenu(content::RenderViewHost* rvh);
 
+  virtual void FrameAdded(WebFrame* frame);
+  virtual void FrameRemoved(WebFrame* frame);
+
  protected:
   WebView();
 
@@ -189,29 +193,12 @@
                           int error_code,
                           const base::string16& error_description);
 
-  void SendErrorForV8Message(long long frame_id,
-                             const std::string& world_id,
-                             int serial,
-                             OxideMsg_SendMessage_Error::Value error_code,
-                             const std::string& error_desc);
-  bool TryDispatchV8MessageToTarget(MessageTarget* target,
-                                    WebFrame* source_frame,
-                                    const std::string& world_id,
-                                    int serial,
-                                    const std::string& msg_id,
-                                    const std::string& args);
-  void DispatchV8Message(const OxideMsg_SendMessage_Params& params);
-
-  void OnFrameCreated(int64 parent_frame_id, int64 frame_id);
-
   virtual void OnURLChanged();
   virtual void OnTitleChanged();
   virtual void OnCommandsUpdated();
 
   virtual void OnLoadProgressChanged(double progress);
 
-  virtual void OnRootFrameChanged();
-
   virtual void OnLoadStarted(const GURL& validated_url,
                              bool is_error_frame);
   virtual void OnLoadStopped(const GURL& validated_url);
@@ -224,12 +211,14 @@
   virtual void OnNavigationListPruned(bool from_front, int count);
   virtual void OnNavigationEntryChanged(int index);
 
-  virtual WebFrame* CreateWebFrame() = 0;
-
-  scoped_ptr<content::WebContents> web_contents_;
+  virtual WebFrame* CreateWebFrame(content::FrameTreeNode* node) = 0;
+
+  scoped_ptr<content::WebContentsImpl> web_contents_;
+  scoped_ptr<content::NotificationRegistrar> registrar_;
+
   WebFrame* root_frame_;
 
-  scoped_ptr<content::NotificationRegistrar> registrar_;
+  WebPreferences* web_preferences_;
 
   DISALLOW_COPY_AND_ASSIGN(WebView);
 };

=== modified file 'shared/common/oxide_message_enums.h'
--- shared/common/oxide_message_enums.h	2013-11-20 19:04:45 +0000
+++ shared/common/oxide_message_enums.h	2014-02-07 16:51:32 +0000
@@ -44,13 +44,8 @@
     // No handler was registered for this message
     NO_HANDLER,
 
-    // The handler reported an error
-    HANDLER_REPORTED_ERROR,
-
-    // The frame disappeared before sending a response was sent
-    // (only valid for embedder to content script messages, and
-    //  never actually sent across the wire)
-    FRAME_DISAPPEARED,
+    // The handler reported an error via the error() function
+    HANDLER_REPORTED_ERROR
   };
 };
 

=== modified file 'shared/common/oxide_messages.h'
--- shared/common/oxide_messages.h	2013-11-20 19:02:08 +0000
+++ shared/common/oxide_messages.h	2014-02-07 16:51:32 +0000
@@ -27,13 +27,12 @@
 IPC_ENUM_TRAITS(OxideMsg_SendMessage_Error::Value)
 
 IPC_STRUCT_BEGIN(OxideMsg_SendMessage_Params)
-  IPC_STRUCT_MEMBER(long long, frame_id)
   IPC_STRUCT_MEMBER(std::string, world_id)
   IPC_STRUCT_MEMBER(int, serial)
   IPC_STRUCT_MEMBER(OxideMsg_SendMessage_Type::Value, type)
   IPC_STRUCT_MEMBER(OxideMsg_SendMessage_Error::Value, error)
   IPC_STRUCT_MEMBER(std::string, msg_id)
-  IPC_STRUCT_MEMBER(std::string, args)
+  IPC_STRUCT_MEMBER(std::string, payload)
 IPC_STRUCT_END()
 
 #define IPC_MESSAGE_START OxideMsgStart

=== modified file 'shared/renderer/oxide_content_renderer_client.cc'
--- shared/renderer/oxide_content_renderer_client.cc	2013-11-20 19:02:08 +0000
+++ shared/renderer/oxide_content_renderer_client.cc	2014-02-07 16:51:32 +0000
@@ -21,7 +21,6 @@
 #include "oxide_process_observer.h"
 #include "oxide_user_script_scheduler.h"
 #include "oxide_user_script_slave.h"
-#include "oxide_web_frame_observer.h"
 
 namespace oxide {
 
@@ -32,14 +31,19 @@
 void ContentRendererClient::RenderThreadStarted() {
   process_observer_.reset(new ProcessObserver());
   user_script_slave_.reset(new UserScriptSlave());
-  message_dispatcher_.reset(new MessageDispatcherRenderer());
+}
+
+void ContentRendererClient::RenderFrameCreated(
+    content::RenderFrame* render_frame) {
+  new MessageDispatcherRenderer(render_frame);
 }
 
 void ContentRendererClient::RenderViewCreated(
     content::RenderView* render_view) {
+  // XXX: This is currently here because RenderFrame proxies the
+  //      notifications we're interested in to RenderView. Make this
+  //      a RenderFrameObserver when it grows the features we need
   new UserScriptScheduler(render_view);
-  new MessageDispatcherRenderer::EndPoint(render_view);
-  new WebFrameObserver(render_view);
 }
 
 void ContentRendererClient::DidCreateScriptContext(
@@ -47,14 +51,16 @@
     v8::Handle<v8::Context> context,
     int extension_group,
     int world_id) {
-  message_dispatcher_->DidCreateScriptContext(frame, context, world_id);
+  MessageDispatcherRenderer::FromWebFrame(
+      frame)->DidCreateScriptContext(context, world_id);
 }
 
 void ContentRendererClient::WillReleaseScriptContext(
     blink::WebFrame* frame,
     v8::Handle<v8::Context> context,
     int world_id) {
-  message_dispatcher_->WillReleaseScriptContext(frame, context, world_id);
+  MessageDispatcherRenderer::FromWebFrame(
+      frame)->WillReleaseScriptContext(context, world_id);
 }
 
 } // namespace oxide

=== modified file 'shared/renderer/oxide_content_renderer_client.h'
--- shared/renderer/oxide_content_renderer_client.h	2013-11-20 19:02:08 +0000
+++ shared/renderer/oxide_content_renderer_client.h	2014-02-07 16:51:32 +0000
@@ -26,7 +26,6 @@
 
 namespace oxide {
 
-class MessageDispatcherRenderer;
 class ProcessObserver;
 class UserScriptSlave;
 
@@ -38,12 +37,10 @@
   UserScriptSlave* user_script_slave() const {
     return user_script_slave_.get();
   }
-  MessageDispatcherRenderer* message_dispatcher() const {
-    return message_dispatcher_.get();
-  }
 
   void RenderThreadStarted() FINAL;
 
+  void RenderFrameCreated(content::RenderFrame* render_frame) FINAL;
   void RenderViewCreated(content::RenderView* render_view) FINAL;
 
   void DidCreateScriptContext(blink::WebFrame* frame,
@@ -57,7 +54,6 @@
  private:
   scoped_ptr<ProcessObserver> process_observer_;
   scoped_ptr<UserScriptSlave> user_script_slave_;
-  scoped_ptr<MessageDispatcherRenderer> message_dispatcher_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentRendererClient);
 };

=== modified file 'shared/renderer/oxide_message_dispatcher_renderer.cc'
--- shared/renderer/oxide_message_dispatcher_renderer.cc	2014-01-07 01:08:00 +0000
+++ shared/renderer/oxide_message_dispatcher_renderer.cc	2014-02-07 16:51:32 +0000
@@ -17,48 +17,36 @@
 
 #include "oxide_message_dispatcher_renderer.h"
 
+#include <map>
+#include <utility>
+
+#include "base/lazy_instance.h"
+#include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_thread.h"
-#include "content/public/renderer/render_view.h"
+#include "ipc/ipc_message.h"
+#include "ipc/ipc_message_macros.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 
-#include "shared/common/oxide_content_client.h"
 #include "shared/common/oxide_messages.h"
 
-#include "oxide_content_renderer_client.h"
 #include "oxide_isolated_world_map.h"
 #include "oxide_v8_message_manager.h"
 
 namespace oxide {
 
-void MessageDispatcherRenderer::EndPoint::OnReceiveMessage(
-    const OxideMsg_SendMessage_Params& params) {
-  ContentClient::instance()->renderer()->message_dispatcher()->
-      OnReceiveMessage(render_view(), params);
-}
-
-MessageDispatcherRenderer::EndPoint::EndPoint(content::RenderView* render_view) :
-    content::RenderViewObserver(render_view) {}
-
-bool MessageDispatcherRenderer::EndPoint::OnMessageReceived(
-    const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(EndPoint, message)
-    IPC_MESSAGE_HANDLER(OxideMsg_SendMessage, OnReceiveMessage)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-
-  return handled;
+namespace {
+typedef std::map<content::RenderFrame*, MessageDispatcherRenderer*> MessageDispatcherMap;
+typedef MessageDispatcherMap::iterator MessageDispatcherMapIterator;
+base::LazyInstance<MessageDispatcherMap> g_dispatcher_map =
+    LAZY_INSTANCE_INITIALIZER;
 }
 
 void MessageDispatcherRenderer::OnReceiveMessage(
-    content::RenderView* render_view,
     const OxideMsg_SendMessage_Params& params) {
   for (MessageManagerVector::iterator it = message_managers_.begin();
        it != message_managers_.end(); ++it) {
     linked_ptr<V8MessageManager> mm = *it;
-    if (mm->frame_id() == params.frame_id &&
-        mm->world_id() == IsolatedWorldMap::NameToID(params.world_id) &&
-        mm->render_view() == render_view) {
+    if (mm->world_id() == IsolatedWorldMap::NameToID(params.world_id)) {
       mm->ReceiveMessage(params);
       return;
     }
@@ -69,25 +57,56 @@
   }
 
   OxideMsg_SendMessage_Params error_params;
-  error_params.frame_id = params.frame_id;
   error_params.world_id = params.world_id;
   error_params.serial = params.serial;
   error_params.type = OxideMsg_SendMessage_Type::Reply;
   error_params.error = OxideMsg_SendMessage_Error::INVALID_DESTINATION;
   error_params.msg_id = params.msg_id;
-  error_params.args = std::string("Invalid frame or world ID");
-
-  content::RenderThread::Get()->Send(
-      new OxideHostMsg_SendMessage(render_view->GetRoutingID(),
-                                   error_params));
-}
-
-MessageDispatcherRenderer::MessageDispatcherRenderer() {}
-
-MessageDispatcherRenderer::~MessageDispatcherRenderer() {}
+  error_params.payload = std::string(
+      "Could not deliver message. The specified world ID does not exist");
+
+  Send(new OxideHostMsg_SendMessage(routing_id(), error_params));
+}
+
+bool MessageDispatcherRenderer::OnMessageReceived(const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(MessageDispatcherRenderer, message)
+    IPC_MESSAGE_HANDLER(OxideMsg_SendMessage, OnReceiveMessage)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+
+  return handled;
+}
+
+MessageDispatcherRenderer::MessageDispatcherRenderer(
+    content::RenderFrame* frame) :
+    content::RenderFrameObserver(frame) {
+  std::pair<MessageDispatcherMapIterator, bool> rv =
+      g_dispatcher_map.Get().insert(std::make_pair(frame, this));
+  CHECK(rv.second);
+}
+
+MessageDispatcherRenderer::~MessageDispatcherRenderer() {
+  // RenderFrameObserver has already cleared it's pointer to our RenderFrame
+  for (MessageDispatcherMapIterator it = g_dispatcher_map.Get().begin();
+       it != g_dispatcher_map.Get().end(); ++it) {
+    MessageDispatcherMap::value_type& v = *it;
+    if (v.second == this) {
+      g_dispatcher_map.Get().erase(it);
+      break;
+    }
+  }
+}
+
+// static
+MessageDispatcherRenderer* MessageDispatcherRenderer::FromWebFrame(
+    blink::WebFrame* frame) {
+  content::RenderFrame* rf = content::RenderFrame::FromWebFrame(frame);
+  MessageDispatcherMapIterator it = g_dispatcher_map.Get().find(rf);
+  return it == g_dispatcher_map.Get().end() ? NULL : it->second;
+}
 
 void MessageDispatcherRenderer::DidCreateScriptContext(
-    blink::WebFrame* frame,
     v8::Handle<v8::Context> context,
     int world_id) {
   if (world_id < 1) {
@@ -95,13 +114,12 @@
   }
 
   message_managers_.push_back(
-      linked_ptr<V8MessageManager>(new V8MessageManager(frame,
+      linked_ptr<V8MessageManager>(new V8MessageManager(render_frame(),
                                                         context,
                                                         world_id)));
 }
 
 void MessageDispatcherRenderer::WillReleaseScriptContext(
-    blink::WebFrame* frame,
     v8::Handle<v8::Context> context,
     int world_id) {
   if (world_id < 1) {

=== modified file 'shared/renderer/oxide_message_dispatcher_renderer.h'
--- shared/renderer/oxide_message_dispatcher_renderer.h	2013-11-20 19:02:08 +0000
+++ shared/renderer/oxide_message_dispatcher_renderer.h	2014-02-07 16:51:32 +0000
@@ -23,12 +23,12 @@
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/linked_ptr.h"
-#include "content/public/renderer/render_view_observer.h"
+#include "content/public/renderer/render_frame_observer.h"
 #include "v8/include/v8.h"
 
 struct OxideMsg_SendMessage_Params;
 
-namespace WebKit {
+namespace blink {
 class WebFrame;
 }
 
@@ -36,40 +36,24 @@
 
 class V8MessageManager;
 
-class MessageDispatcherRenderer FINAL {
+class MessageDispatcherRenderer FINAL : public content::RenderFrameObserver {
  public:
-
-  // XXX: Not sure if this is really necessary - should we just use control
-  //      (non-routed) messages for this, and use RenderProcessObserver
-  //      instead?
-  class EndPoint FINAL : public content::RenderViewObserver {
-   public:
-    EndPoint(content::RenderView* render_view);
-
-    bool OnMessageReceived(const IPC::Message& message) FINAL;
-
-   private:
-    void OnReceiveMessage(const OxideMsg_SendMessage_Params& params);
-
-    DISALLOW_IMPLICIT_CONSTRUCTORS(EndPoint);
-  };
-
-  MessageDispatcherRenderer();
+  MessageDispatcherRenderer(content::RenderFrame* frame);
   ~MessageDispatcherRenderer();
 
-  void DidCreateScriptContext(blink::WebFrame* frame,
-                              v8::Handle<v8::Context> context,
+  static MessageDispatcherRenderer* FromWebFrame(blink::WebFrame* frame);
+
+  void DidCreateScriptContext(v8::Handle<v8::Context> context,
                               int world_id);
 
-  void WillReleaseScriptContext(blink::WebFrame* frame,
-                                v8::Handle<v8::Context> context,
+  void WillReleaseScriptContext(v8::Handle<v8::Context> context,
                                 int world_id);
 
  private:
   typedef std::vector<linked_ptr<V8MessageManager> > MessageManagerVector;
 
-  void OnReceiveMessage(content::RenderView* render_view,
-                        const OxideMsg_SendMessage_Params& params);
+  bool OnMessageReceived(const IPC::Message& message) FINAL;
+  void OnReceiveMessage(const OxideMsg_SendMessage_Params& params);
 
   MessageManagerVector message_managers_;
 

=== modified file 'shared/renderer/oxide_v8_message_manager.cc'
--- shared/renderer/oxide_v8_message_manager.cc	2014-01-20 12:35:23 +0000
+++ shared/renderer/oxide_v8_message_manager.cc	2014-02-07 16:51:32 +0000
@@ -23,8 +23,7 @@
 #include "base/strings/string16.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
-#include "content/public/renderer/render_thread.h"
-#include "content/public/renderer/render_view.h"
+#include "content/public/renderer/render_frame.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebScopedMicrotaskSuppression.h"
 #include "ui/base/resource/resource_bundle.h"
@@ -145,35 +144,33 @@
 
   v8::Local<v8::String> msg_id = msg_id_as_val->ToString();
 
-  v8::Local<v8::String> msg_args;
+  v8::Local<v8::String> msg_payload;
   if (args.Length() > 4) {
-    v8::Local<v8::Value> msg_args_as_val = args[4];
-    if (!msg_args_as_val->IsString()) {
+    v8::Local<v8::Value> msg_payload_as_val = args[4];
+    if (!msg_payload_as_val->IsString()) {
       isolate->ThrowException(v8::Exception::Error(
           v8::String::NewFromUtf8(
             isolate, "Invalid argument type")));
       return;
     }
 
-    msg_args = msg_args_as_val->ToString();
+    msg_payload = msg_payload_as_val->ToString();
   } else if (error != OxideMsg_SendMessage_Error::OK) {
-    msg_args = v8::String::Empty(isolate);
+    msg_payload = v8::String::Empty(isolate);
   } else {
-    msg_args = v8::String::NewFromUtf8(isolate, "{}");
+    msg_payload = v8::String::NewFromUtf8(isolate, "{}");
   }
 
   OxideMsg_SendMessage_Params params;
-  params.frame_id = frame_->identifier();
   params.world_id = IsolatedWorldMap::IDToName(world_id_);
   params.serial = serial->Value();
   params.type = type;
   params.error = error;
   params.msg_id = V8StringToStdString(msg_id);
-  params.args = V8StringToStdString(msg_args);
+  params.payload = V8StringToStdString(msg_payload);
 
-  content::RenderThread::Get()->Send(
-      new OxideHostMsg_SendMessage(render_view()->GetRoutingID(),
-                                   params));
+  frame_->Send(new OxideHostMsg_SendMessage(
+      frame_->GetRoutingID(), params));
 }
 
 void V8MessageManager::RegisterReceiveHandlerInner(
@@ -264,7 +261,7 @@
 
   {
     blink::WebScopedMicrotaskSuppression mts;
-    frame_->callFunctionEvenIfScriptDisabled(
+    frame_->GetWebFrame()->callFunctionEvenIfScriptDisabled(
         function,
         context_.NewHandle(isolate)->Global(),
         arraysize(args),
@@ -280,7 +277,7 @@
   info.GetReturnValue().Set(exports);
 }
 
-V8MessageManager::V8MessageManager(blink::WebFrame* frame,
+V8MessageManager::V8MessageManager(content::RenderFrame* frame,
                                    v8::Handle<v8::Context> context,
                                    int world_id) :
     frame_(frame),
@@ -315,11 +312,11 @@
     v8::Integer::New(isolate, params.type),
     v8::Integer::New(isolate, params.error),
     v8::String::NewFromUtf8(isolate, params.msg_id.data()),
-    v8::String::NewFromUtf8(isolate, params.args.data())
+    v8::String::NewFromUtf8(isolate, params.payload.data())
   };
 
   v8::TryCatch try_catch;
-  frame_->callFunctionEvenIfScriptDisabled(
+  frame_->GetWebFrame()->callFunctionEvenIfScriptDisabled(
       receive_handler_.NewHandle(isolate),
       context_.NewHandle(isolate)->Global(),
       arraysize(args),
@@ -327,7 +324,6 @@
   if (try_catch.HasCaught() &&
       params.type == OxideMsg_SendMessage_Type::Message) {
     OxideMsg_SendMessage_Params error_params;
-    error_params.frame_id = params.frame_id;
     error_params.world_id = params.world_id;
     error_params.serial = params.serial;
     error_params.type = OxideMsg_SendMessage_Type::Reply;
@@ -337,14 +333,11 @@
     v8::Local<v8::Message> msg(try_catch.Message());
     if (!msg.IsEmpty()) {
       v8::Local<v8::String> s(msg->Get());
-      error_params.args = V8StringToStdString(s);
-    } else {
-      error_params.args = std::string("Handler threw an exception");
+      error_params.payload = V8StringToStdString(s);
     }
 
-    content::RenderThread::Get()->Send(
-        new OxideHostMsg_SendMessage(render_view()->GetRoutingID(),
-                                     error_params));
+    frame_->Send(new OxideHostMsg_SendMessage(
+        frame_->GetRoutingID(), error_params));
   }
 }
 
@@ -352,12 +345,4 @@
   return context_.NewHandle(v8::Isolate::GetCurrent());
 }
 
-long long V8MessageManager::frame_id() const {
-  return frame_->identifier();
-}
-
-content::RenderView* V8MessageManager::render_view() const {
-  return content::RenderView::FromWebView(frame_->view());
-}
-
 } // namespace oxide

=== modified file 'shared/renderer/oxide_v8_message_manager.h'
--- shared/renderer/oxide_v8_message_manager.h	2013-11-20 19:02:08 +0000
+++ shared/renderer/oxide_v8_message_manager.h	2014-02-07 16:51:32 +0000
@@ -28,11 +28,8 @@
 
 struct OxideMsg_SendMessage_Params;
 
-namespace blink {
-class WebFrame;
-}
-
 namespace content {
+class RenderFrame;
 class RenderView;
 }
 
@@ -40,7 +37,7 @@
 
 class V8MessageManager FINAL {
  public:
-  V8MessageManager(blink::WebFrame* frame,
+  V8MessageManager(content::RenderFrame* frame,
                    v8::Handle<v8::Context> context,
                    int world_id);
   ~V8MessageManager();
@@ -48,9 +45,7 @@
   void ReceiveMessage(const OxideMsg_SendMessage_Params& params);
 
   v8::Handle<v8::Context> v8_context() const;
-  long long frame_id() const;
   int world_id() const { return world_id_; }
-  content::RenderView* render_view() const;
 
  private:
   static std::string V8StringToStdString(v8::Local<v8::String> string);
@@ -72,7 +67,7 @@
   void OxideLazyGetterInner(v8::Local<v8::String> property,
                             const v8::PropertyCallbackInfo<v8::Value>& info);
 
-  blink::WebFrame* frame_;
+  content::RenderFrame* frame_;
   ScopedPersistent<v8::Context> context_;
   int world_id_;
   ScopedPersistent<v8::External> closure_data_;

=== removed file 'shared/renderer/oxide_web_frame_observer.cc'
--- shared/renderer/oxide_web_frame_observer.cc	2013-11-20 19:02:08 +0000
+++ shared/renderer/oxide_web_frame_observer.cc	1970-01-01 00:00:00 +0000
@@ -1,40 +0,0 @@
-// vim:expandtab:shiftwidth=2:tabstop=2:
-// Copyright (C) 2013 Canonical Ltd.
-
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// Lesser General Public License for more details.
-
-// You should have received a copy of the GNU Lesser General Public
-// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-
-#include "oxide_web_frame_observer.h"
-
-#include "content/public/renderer/render_view.h"
-#include "third_party/WebKit/public/web/WebFrame.h"
-
-#include "shared/common/oxide_messages.h"
-
-namespace oxide {
-
-WebFrameObserver::WebFrameObserver(content::RenderView* render_view) :
-    content::RenderViewObserver(render_view) {}
-
-WebFrameObserver::~WebFrameObserver() {}
-
-void WebFrameObserver::FrameCreated(blink::WebFrame* parent,
-                                    blink::WebFrame* frame) {
-  render_view()->Send(
-      new OxideHostMsg_FrameCreated(routing_id(),
-                                    parent->identifier(),
-                                    frame->identifier()));
-}
-
-} // namespace oxide

=== removed file 'shared/renderer/oxide_web_frame_observer.h'
--- shared/renderer/oxide_web_frame_observer.h	2013-11-20 19:02:08 +0000
+++ shared/renderer/oxide_web_frame_observer.h	1970-01-01 00:00:00 +0000
@@ -1,41 +0,0 @@
-// vim:expandtab:shiftwidth=2:tabstop=2:
-// Copyright (C) 2013 Canonical Ltd.
-
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// Lesser General Public License for more details.
-
-// You should have received a copy of the GNU Lesser General Public
-// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-
-#ifndef _OXIDE_SHARED_RENDERER_WEB_FRAME_OBSERVER_H_
-#define _OXIDE_SHARED_RENDERER_WEB_FRAME_OBSERVER_H_
-
-#include "base/basictypes.h"
-#include "base/compiler_specific.h"
-#include "content/public/renderer/render_view_observer.h"
-
-namespace oxide {
-
-class WebFrameObserver FINAL : public content::RenderViewObserver {
- public:
-  WebFrameObserver(content::RenderView* render_view);
-  virtual ~WebFrameObserver();
-
-  void FrameCreated(blink::WebFrame* parent,
-                    blink::WebFrame* frame) FINAL;
-
- private:
-  DISALLOW_IMPLICIT_CONSTRUCTORS(WebFrameObserver);
-};
-
-};
-
-#endif // _OXIDE_SHARED_RENDERER_WEB_FRAME_OBSERVER_H_

=== modified file 'shared/shared.gyp'
--- shared/shared.gyp	2014-01-30 10:57:52 +0000
+++ shared/shared.gyp	2014-02-07 16:51:32 +0000
@@ -148,6 +148,8 @@
         'browser/oxide_incoming_message.h',
         'browser/oxide_io_thread_delegate.cc',
         'browser/oxide_io_thread_delegate.h',
+        'browser/oxide_message_dispatcher_browser.cc',
+        'browser/oxide_message_dispatcher_browser.h',
         'browser/oxide_message_handler.cc',
         'browser/oxide_message_handler.h',
         'browser/oxide_message_pump.cc',
@@ -173,6 +175,8 @@
         'browser/oxide_web_frame.h',
         'browser/oxide_web_popup_menu.cc',
         'browser/oxide_web_popup_menu.h',
+        'browser/oxide_web_preferences.cc',
+        'browser/oxide_web_preferences.h',
         'browser/oxide_web_view.cc',
         'browser/oxide_web_view.h',
         'common/oxide_constants.cc',
@@ -213,8 +217,6 @@
         'renderer/oxide_v8_message_manager.cc',
         'renderer/oxide_v8_message_manager.h',
         'renderer/oxide_v8_scoped_persistent.h',
-        'renderer/oxide_web_frame_observer.cc',
-        'renderer/oxide_web_frame_observer.h',
         '<(DEPTH)/extensions/common/constants.cc',
         '<(DEPTH)/extensions/common/constants.h',
         '<(DEPTH)/extensions/common/error_utils.cc',