diff -r 000000000000 -r 6474c204b198 mobile/android/base/tests/components/ToolbarComponent.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mobile/android/base/tests/components/ToolbarComponent.java	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,227 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+package org.mozilla.gecko.tests.components;
+
+import static org.mozilla.gecko.tests.helpers.AssertionHelper.fAssertEquals;
+import static org.mozilla.gecko.tests.helpers.AssertionHelper.fAssertFalse;
+import static org.mozilla.gecko.tests.helpers.AssertionHelper.fAssertNotNull;
+import static org.mozilla.gecko.tests.helpers.AssertionHelper.fAssertTrue;
+
+import org.mozilla.gecko.R;
+import org.mozilla.gecko.tests.UITestContext;
+import org.mozilla.gecko.tests.helpers.DeviceHelper;
+import org.mozilla.gecko.tests.helpers.WaitHelper;
+
+import android.view.View;
+import android.widget.EditText;
+import android.widget.ImageButton;
+import android.widget.TextView;
+
+import com.jayway.android.robotium.solo.Condition;
+import com.jayway.android.robotium.solo.Solo;
+
+/**
+ * A class representing any interactions that take place on the Toolbar.
+ */
+public class ToolbarComponent extends BaseComponent {
+    public ToolbarComponent(final UITestContext testContext) {
+        super(testContext);
+    }
+
+    public ToolbarComponent assertIsEditing() {
+        fAssertTrue("The toolbar is in the editing state", isEditing());
+        return this;
+    }
+
+    public ToolbarComponent assertIsNotEditing() {
+        fAssertFalse("The toolbar is not in the editing state", isEditing());
+        return this;
+    }
+
+    public ToolbarComponent assertTitle(final String expected) {
+        fAssertEquals("The Toolbar title is " + expected, expected, getTitle());
+        return this;
+    }
+
+    public ToolbarComponent assertUrl(final String expected) {
+        assertIsEditing();
+        fAssertEquals("The Toolbar url is " + expected, expected, getUrlEditText().getText());
+        return this;
+    }
+
+    /**
+     * Returns the root View for the browser toolbar.
+     */
+    private View getToolbarView() {
+        return mSolo.getView(R.id.browser_toolbar);
+    }
+
+    private EditText getUrlEditText() {
+        return (EditText) getToolbarView().findViewById(R.id.url_edit_text);
+    }
+
+    private View getUrlDisplayLayout() {
+        return getToolbarView().findViewById(R.id.display_layout);
+    }
+
+    private TextView getUrlTitleText() {
+        return (TextView) getToolbarView().findViewById(R.id.url_bar_title);
+    }
+
+    private ImageButton getBackButton() {
+        DeviceHelper.assertIsTablet();
+        return (ImageButton) getToolbarView().findViewById(R.id.back);
+    }
+
+    private ImageButton getForwardButton() {
+        DeviceHelper.assertIsTablet();
+        return (ImageButton) getToolbarView().findViewById(R.id.forward);
+    }
+
+    /**
+     * Returns the View for the edit cancel button in the browser toolbar.
+     */
+    private ImageButton getEditCancelButton() {
+        return (ImageButton) getToolbarView().findViewById(R.id.edit_cancel);
+    }
+
+    private CharSequence getTitle() {
+        return getTitleHelper(true);
+    }
+
+    /**
+     * Returns the title of the page. Note that this makes no assertions to Toolbar state and
+     * may return a value that may never be visible to the user. Callers likely want to use
+     * {@link assertTitle} instead.
+     */
+    public CharSequence getPotentiallyInconsistentTitle() {
+        return getTitleHelper(false);
+    }
+
+    private CharSequence getTitleHelper(final boolean shouldAssertNotEditing) {
+        if (shouldAssertNotEditing) {
+            assertIsNotEditing();
+        }
+
+        return getUrlTitleText().getText();
+    }
+
+    private boolean isEditing() {
+        return getUrlDisplayLayout().getVisibility() != View.VISIBLE &&
+                getUrlEditText().getVisibility() == View.VISIBLE;
+    }
+
+    public ToolbarComponent enterEditingMode() {
+        assertIsNotEditing();
+
+        mSolo.clickOnView(getUrlTitleText(), true);
+
+        waitForEditing();
+        WaitHelper.waitFor("UrlEditText to be input method target", new Condition() {
+            @Override
+            public boolean isSatisfied() {
+                return getUrlEditText().isInputMethodTarget();
+            }
+        });
+
+        return this;
+    }
+
+    public ToolbarComponent commitEditingMode() {
+        assertIsEditing();
+
+        WaitHelper.waitForPageLoad(new Runnable() {
+            @Override
+            public void run() {
+                mSolo.sendKey(Solo.ENTER);
+            }
+        });
+        waitForNotEditing();
+
+        return this;
+    }
+
+    public ToolbarComponent dismissEditingMode() {
+        assertIsEditing();
+
+        // Cancel Button not implemeneted in tablet.
+        if (DeviceHelper.isTablet()) {
+            if (getUrlEditText().isInputMethodTarget()) {
+                // Drop the soft keyboard.
+                // TODO: Solo.hideSoftKeyboard() does not clear focus, causing unexpected
+                // behavior, but we may want to use it over goBack().
+                mSolo.goBack();
+            }
+
+            mSolo.goBack();
+        } else {
+            mSolo.clickOnView(getEditCancelButton());
+        }
+
+        waitForNotEditing();
+
+        return this;
+    }
+
+    public ToolbarComponent enterUrl(final String url) {
+        fAssertNotNull("url is not null", url);
+
+        assertIsEditing();
+
+        final EditText urlEditText = getUrlEditText();
+        fAssertTrue("The UrlEditText is the input method target",
+                urlEditText.isInputMethodTarget());
+
+        mSolo.clearEditText(urlEditText);
+        mSolo.enterText(urlEditText, url);
+
+        return this;
+    }
+
+    public ToolbarComponent pressBackButton() {
+        final ImageButton backButton = getBackButton();
+        return pressButton(backButton, "back");
+    }
+
+    public ToolbarComponent pressForwardButton() {
+        final ImageButton forwardButton = getForwardButton();
+        return pressButton(forwardButton, "forward");
+    }
+
+    private ToolbarComponent pressButton(final View view, final String buttonName) {
+        fAssertNotNull("The " + buttonName + " button View is not null", view);
+        fAssertTrue("The " + buttonName + " button is enabled", view.isEnabled());
+        fAssertEquals("The " + buttonName + " button is visible",
+                View.VISIBLE, view.getVisibility());
+        assertIsNotEditing();
+
+        WaitHelper.waitForPageLoad(new Runnable() {
+            @Override
+            public void run() {
+                mSolo.clickOnView(view);
+            }
+        });
+
+        return this;
+    }
+
+    private void waitForEditing() {
+        WaitHelper.waitFor("Toolbar to enter editing mode", new Condition() {
+            @Override
+            public boolean isSatisfied() {
+                return isEditing();
+            }
+        });
+    }
+
+    private void waitForNotEditing() {
+        WaitHelper.waitFor("Toolbar to exit editing mode", new Condition() {
+            @Override
+            public boolean isSatisfied() {
+                return !isEditing();
+            }
+        });
+    }
+}