Base framework for new screens.

BUG=231331
TBR=ben@chromium.org
NOTRY=true

Review URL: https://chromiumcodereview.appspot.com/14075015

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@195774 0039d316-1c4b-4281-b951-d872f2087c98

13 files changed, 656 insertions, 21 deletions

diff --git a/chrome/browser/chromeos/login/oobe_display.h b/chrome/browser/chromeos/login/oobe_display.h
index 15fb59e..8f74bf8 100644
--- a/chrome/browser/chromeos/login/oobe_display.h
+++ b/chrome/browser/chromeos/login/oobe_display.h
@@ -8,6 +8,7 @@
 #include <string>
 
 #include "base/basictypes.h"
+#include "base/callback.h"
 
 namespace chromeos {
 
@@ -65,11 +66,14 @@ class OobeDisplay {
   virtual TermsOfServiceScreenActor* GetTermsOfServiceScreenActor() = 0;
   virtual UserImageScreenActor* GetUserImageScreenActor() = 0;
   virtual ErrorScreenActor* GetErrorScreenActor() = 0;
-  // TODO(altimofeev): use real actors instead.
-  virtual ViewScreenDelegate* GetRegistrationScreenActor() = 0;
   virtual WrongHWIDScreenActor* GetWrongHWIDScreenActor() = 0;
   virtual LocallyManagedUserCreationScreenHandler*
       GetLocallyManagedUserCreationScreenActor() = 0;
+
+  // Returns if JS side is fully loaded and ready to accept messages.
+  // If |false| is returned, then |display_is_ready_callback| is stored
+  // and will be called once display is ready.
+  virtual bool IsJSReady(const base::Closure& display_is_ready_callback) = 0;
 };
 
 }  // namespace chromeos
diff --git a/chrome/browser/chromeos/login/screens/base_screen.cc b/chrome/browser/chromeos/login/screens/base_screen.cc
new file mode 100644
index 0000000..f8d78ad
--- /dev/null
+++ b/chrome/browser/chromeos/login/screens/base_screen.cc
@@ -0,0 +1,48 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/chromeos/login/screens/base_screen.h"
+
+#include "chrome/browser/chromeos/login/screens/screen_observer.h"
+
+namespace chromeos {
+
+BaseScreen::BaseScreen() {
+}
+
+BaseScreen::~BaseScreen() {
+}
+
+void BaseScreen::Initialize(ScreenContext* context) {
+}
+
+void BaseScreen::OnShow() {
+}
+
+void BaseScreen::OnHide() {
+}
+
+void BaseScreen::OnClose() {
+}
+
+bool BaseScreen::IsStatusAreaDisplayed() {
+  return true;
+}
+
+bool BaseScreen::IsPermanent() {
+  return false;
+}
+
+std::string BaseScreen::GetID() const {
+  return GetName();
+}
+
+void BaseScreen::Finish(const std::string& outcome) {
+
+}
+
+void BaseScreen::SetContext(ScreenContext* context) {
+}
+
+}  // namespace chromeos
diff --git a/chrome/browser/chromeos/login/screens/base_screen.h b/chrome/browser/chromeos/login/screens/base_screen.h
new file mode 100644
index 0000000..3bf500e
--- /dev/null
+++ b/chrome/browser/chromeos/login/screens/base_screen.h
@@ -0,0 +1,84 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_BASE_SCREEN_H_
+#define CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_BASE_SCREEN_H_
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "chrome/browser/chromeos/login/screens/screen_context.h"
+
+namespace chromeos {
+
+// Base class for the all OOBE/login/before-session screens.
+// Screens are identified by ID, screen and it's JS counterpart must have same
+// id.
+// Most of the screens will be re-created for each appearance with Initialize()
+// method called just once. However if initialization is too expensive, screen
+// can override result of IsPermanent() method, and do clean-up upon subsequent
+// Initialize() method calls.
+class BaseScreen {
+ public:
+  BaseScreen();
+  virtual ~BaseScreen();
+
+  // ---- Old implementation ----
+
+  virtual void PrepareToShow() = 0;
+
+  // Makes wizard screen visible.
+  virtual void Show() = 0;
+
+  // Makes wizard screen invisible.
+  virtual void Hide() = 0;
+
+  // Returns the screen name.
+  virtual std::string GetName() const = 0;
+
+  // ---- New Implementation ----
+
+  // Called to perform initialization of the screen. UI is guaranteed to exist
+  // at this point. Screen can alter context, resulting context will be passed
+  // to JS. This method will be called once per instance of the Screen object,
+  // unless |IsPermanent()| returns |true|.
+  virtual void Initialize(ScreenContext* context);
+
+  // Called when screen appears.
+  virtual void OnShow();
+  // Called when screen disappears, either because it finished it's work, or
+  // because some other screen pops up.
+  virtual void OnHide();
+
+  // Called when we navigate from screen so that we will never return to it.
+  // This is a last chance to call JS counterpart, this object will be deleted
+  // soon.
+  virtual void OnClose();
+
+  // Indicates whether status area should be displayed while this screen is
+  // displayed.
+  virtual bool IsStatusAreaDisplayed();
+
+  // If this method returns |true|, screen will not be deleted once we leave it.
+  // However, Initialize() might be called several times in this case.
+  virtual bool IsPermanent();
+
+  // Returns the identifier of the screen.
+  virtual std::string GetID() const;
+
+ protected:
+  // Screen can call this method to notify framework that it have finished
+  // it's work with |outcome|.
+  void Finish(const std::string& outcome);
+
+ private:
+  friend class ScreenManager;
+  void SetContext(ScreenContext* context);
+
+  DISALLOW_COPY_AND_ASSIGN(BaseScreen);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_BASE_SCREEN_H_
diff --git a/chrome/browser/chromeos/login/screens/screen_context.h b/chrome/browser/chromeos/login/screens/screen_context.h
new file mode 100644
index 0000000..951ed8e
--- /dev/null
+++ b/chrome/browser/chromeos/login/screens/screen_context.h
@@ -0,0 +1,22 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_SCREEN_CONTEXT_H_
+#define CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_SCREEN_CONTEXT_H_
+
+#include <string>
+
+namespace chromeos {
+
+// Placeholder for class that will be used to easily share values between JS and
+// C++ screens.
+class ScreenContext {
+ public:
+  ScreenContext() {}
+  ~ScreenContext() {}
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_SCREEN_CONTEXT_H_
diff --git a/chrome/browser/chromeos/login/screens/screen_factory.cc b/chrome/browser/chromeos/login/screens/screen_factory.cc
new file mode 100644
index 0000000..dc2d5d1
--- /dev/null
+++ b/chrome/browser/chromeos/login/screens/screen_factory.cc
@@ -0,0 +1,86 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/chromeos/login/screens/screen_factory.h"
+
+#include "chrome/browser/chromeos/login/enrollment/enrollment_screen.h"
+#include "chrome/browser/chromeos/login/managed/locally_managed_user_creation_screen.h"
+#include "chrome/browser/chromeos/login/screens/base_screen.h"
+#include "chrome/browser/chromeos/login/screens/error_screen.h"
+#include "chrome/browser/chromeos/login/screens/eula_screen.h"
+#include "chrome/browser/chromeos/login/screens/network_screen.h"
+#include "chrome/browser/chromeos/login/screens/reset_screen.h"
+#include "chrome/browser/chromeos/login/screens/terms_of_service_screen.h"
+#include "chrome/browser/chromeos/login/screens/update_screen.h"
+#include "chrome/browser/chromeos/login/screens/user_image_screen.h"
+#include "chrome/browser/chromeos/login/screens/wrong_hwid_screen.h"
+
+namespace chromeos {
+
+// static
+const char ScreenFactory::kEnrollmentScreenId[] = "enroll";
+const char ScreenFactory::kErrorScreenId[] = "error-message";
+const char ScreenFactory::kEulaScreenId[] = "eula";
+const char ScreenFactory::kLocallyManagedUserCreationScreenId[] =
+  "locally-managed-user-creation-flow";
+const char ScreenFactory::kNetworkScreenId[] = "network";
+const char ScreenFactory::kResetScreenId[] = "reset";
+const char ScreenFactory::kTermsOfServiceScreenId[] = "tos";
+const char ScreenFactory::kUpdateScreenId[] = "update";
+const char ScreenFactory::kUserImageScreenId[] = "image";
+const char ScreenFactory::kWrongHWIDScreenId[] = "wrong-hwid";
+
+const char ScreenFactory::kLoginScreenId[] = "login";
+
+ScreenFactory::ScreenFactory(ScreenObserver* observer,
+                             OobeDisplay* oobe_display)
+    : observer_(observer),
+      oobe_display_(oobe_display) {
+}
+
+ScreenFactory::~ScreenFactory() {
+}
+
+BaseScreen* ScreenFactory::CreateScreen(const std::string& id) {
+  BaseScreen* result = CreateScreenImpl(id);
+  DCHECK_EQ(id, result->GetID());
+  return result;
+}
+
+BaseScreen* ScreenFactory::CreateScreenImpl(const std::string& id) {
+  if (id == kNetworkScreenId) {
+    return new NetworkScreen(observer_, oobe_display_->GetNetworkScreenActor());
+  } else if (id == kUpdateScreenId) {
+    return new UpdateScreen(observer_, oobe_display_->GetUpdateScreenActor());
+  } else if (id == kUserImageScreenId) {
+    return new UserImageScreen(observer_,
+                               oobe_display_->GetUserImageScreenActor());
+  } else if (id == kEulaScreenId) {
+    return new EulaScreen(observer_, oobe_display_->GetEulaScreenActor());
+  } else if (id == kEnrollmentScreenId) {
+    return new EnrollmentScreen(observer_,
+                                oobe_display_->GetEnrollmentScreenActor());
+  } else if (id == kResetScreenId) {
+    return new ResetScreen(observer_, oobe_display_->GetResetScreenActor());
+  } else if (id == kTermsOfServiceScreenId) {
+    return new TermsOfServiceScreen(observer_,
+        oobe_display_->GetTermsOfServiceScreenActor());
+  } else if (id == kWrongHWIDScreenId) {
+    return new WrongHWIDScreen(
+        observer_,
+        oobe_display_->GetWrongHWIDScreenActor());
+  } else if (id == kLocallyManagedUserCreationScreenId) {
+    return new LocallyManagedUserCreationScreen(
+        observer_,
+        oobe_display_->GetLocallyManagedUserCreationScreenActor());
+  } else if (id == kErrorScreenId) {
+    return new ErrorScreen(observer_, oobe_display_->GetErrorScreenActor());
+  }
+
+  // TODO(antrim): support for login screen.
+  NOTREACHED() << "Unknown screen ID: " << id;
+  return NULL;
+}
+
+}  // namespace chromeos
diff --git a/chrome/browser/chromeos/login/screens/screen_factory.h b/chrome/browser/chromeos/login/screens/screen_factory.h
new file mode 100644
index 0000000..29728af
--- /dev/null
+++ b/chrome/browser/chromeos/login/screens/screen_factory.h
@@ -0,0 +1,58 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_SCREEN_FACTORY_H_
+#define CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_SCREEN_FACTORY_H_
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "chrome/browser/chromeos/login/screens/base_screen.h"
+
+namespace chromeos {
+
+class OobeDisplay;
+class ScreenObserver;
+
+// Class that can instantiate screens by name.
+class ScreenFactory {
+ public:
+  static const char kEnrollmentScreenId[];
+  static const char kErrorScreenId[];
+  static const char kEulaScreenId[];
+  static const char kLocallyManagedUserCreationScreenId[];
+  static const char kLoginScreenId[];
+  static const char kNetworkScreenId[];
+  static const char kResetScreenId[];
+  static const char kTermsOfServiceScreenId[];
+  static const char kUpdateScreenId[];
+  static const char kUserImageScreenId[];
+  static const char kWrongHWIDScreenId[];
+
+  // |observer| to be passed to each created screen for providing screen
+  // outcome. Legacy, should be gone once refactoring is finished.
+  // |oobe_display| is a source for all the Handlers required for screens.
+  ScreenFactory(ScreenObserver* observer,
+                OobeDisplay* oobe_display);
+  virtual ~ScreenFactory();
+
+  // Create a screen given its |id|.
+  BaseScreen* CreateScreen(const std::string& id);
+
+ private:
+  BaseScreen* CreateScreenImpl(const std::string& id);
+
+  // Not owned. Screen observer for created screens. Legacy, should be gone
+  // once refactoring is finished.
+  ScreenObserver* observer_;
+
+  // Now owned. Source of Handler objects for created screens.
+  OobeDisplay* oobe_display_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScreenFactory);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_SCREEN_FACTORY_H_
diff --git a/chrome/browser/chromeos/login/screens/screen_flow.h b/chrome/browser/chromeos/login/screens/screen_flow.h
new file mode 100644
index 0000000..ddc3900
--- /dev/null
+++ b/chrome/browser/chromeos/login/screens/screen_flow.h
@@ -0,0 +1,53 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_SCREEN_FLOW_H_
+#define CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_SCREEN_FLOW_H_
+
+#include <string>
+
+#include "base/basictypes.h"
+
+namespace chromeos {
+
+class ScreenContext;
+class ScreenManager;
+
+// Class that holds the logic of interpreting screen outcomes and moving between
+// the screens.
+class ScreenFlow {
+ public:
+  ScreenFlow();
+  virtual ~ScreenFlow();
+
+  // Called once the flow is set as a flow for specific screen manager.
+  // Should usually result in get_manager()->ShowScreen call.
+  virtual void Start() = 0;
+
+  // Called when screen with |screen_id| finishes with |outcome|.
+  // Additional result parameters may be passed via |context| (always not NULL).
+  // Should result in get_manager()->ShowScreen call or in
+  // get_manager()->SetScreenFlow call.
+  virtual void OnScreenFinished(const std::string& screen_id,
+                                const std::string& outcome,
+                                ScreenContext* context) = 0;
+ protected:
+  ScreenManager* screen_manager() { return manager_; }
+
+ private:
+  friend class ScreenManager;
+
+  void set_screen_manager(ScreenManager* manager) {
+    manager_ = manager;
+  }
+
+  // Screen manager associated with this flow. Set by screen manager itself.
+  ScreenManager* manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScreenFlow);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_SCREEN_FLOW_H_
diff --git a/chrome/browser/chromeos/login/screens/screen_manager.cc b/chrome/browser/chromeos/login/screens/screen_manager.cc
new file mode 100644
index 0000000..4cf100e
--- /dev/null
+++ b/chrome/browser/chromeos/login/screens/screen_manager.cc
@@ -0,0 +1,155 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/chromeos/login/screens/screen_manager.h"
+
+#include "base/bind.h"
+#include "base/logging.h"
+#include "chrome/browser/chromeos/login/oobe_display.h"
+#include "chrome/browser/chromeos/login/screens/base_screen.h"
+#include "chrome/browser/chromeos/login/screens/screen_factory.h"
+#include "chrome/browser/chromeos/login/screens/screen_flow.h"
+
+namespace chromeos {
+
+ScreenManager::ScreenManager(ScreenFactory* factory,
+                             OobeDisplay* oobe_display,
+                             ScreenFlow* initial_flow)
+    : factory_(factory),
+      display_(oobe_display),
+      flow_(initial_flow),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
+  js_is_ready_ = display_->IsJSReady(
+      base::Bind(&ScreenManager::OnDisplayIsReady, weak_factory_.GetWeakPtr()));
+}
+
+ScreenManager::~ScreenManager() {
+}
+
+void ScreenManager::WarmupScreen(const std::string& id,
+                                 ScreenContext* context) {
+
+}
+
+void ScreenManager::ShowScreen(const std::string& id) {
+  ShowScreenImpl(id, new ScreenContext(), false);
+}
+
+void ScreenManager::ShowScreenWithParameters(const std::string& id,
+                                             ScreenContext* context) {
+  ShowScreenImpl(id, context, false);
+}
+
+void ScreenManager::PopupScreen(const std::string& id) {
+  ShowScreenImpl(id, new ScreenContext(), true);
+}
+
+void ScreenManager::PopupScreenWithParameters(const std::string& id,
+                                              ScreenContext* context) {
+  ShowScreenImpl(id, context, true);
+}
+
+std::string ScreenManager::GetCurrentScreenId() {
+  DCHECK(!screen_stack_.empty());
+  return screen_stack_.top();
+}
+
+void ScreenManager::HidePopupScreen(const std::string& screen_id) {
+  DCHECK(!screen_stack_.empty());
+  DCHECK_EQ(screen_stack_.top(), screen_id);
+
+  // TODO(antrim): check that id really exist in stack.
+  std::string previous_screen = GetCurrentScreenId();
+  GetTopmostScreen()->OnHide();
+  TearDownTopmostScreen();
+  screen_stack_.pop();
+
+  std::string screen_below;
+  if (!screen_stack_.empty()) {
+    screen_below = GetCurrentScreenId();
+    GetTopmostScreen()->OnShow();
+  }
+  TransitionScreen(previous_screen, screen_below);
+}
+
+void ScreenManager::ShowScreenImpl(const std::string& id,
+                                   ScreenContext* context,
+                                   bool popup) {
+  if (!js_is_ready_) {
+    DCHECK(!start_screen_params_.get());
+    start_screen_params_.reset(context);
+    start_screen_popup_ = popup;
+    start_screen_ = id;
+    return;
+  }
+  DCHECK(popup || screen_stack_.size() <= 1);
+  BaseScreen* screen = FindOrCreateScreen(id);
+  screen->SetContext(context);
+  screen->Initialize(context);
+
+  std::string previous_screen;
+  if (!screen_stack_.empty()) {
+    previous_screen = GetCurrentScreenId();
+    GetTopmostScreen()->OnHide();
+    if (!popup)
+      TearDownTopmostScreen();
+  }
+
+  DCHECK(popup || screen_stack_.empty());
+  screen_stack_.push(id);
+  screen->OnShow();
+  TransitionScreen(previous_screen, id);
+}
+
+void ScreenManager::TransitionScreen(const std::string& from_id,
+                                     const std::string& to_id) {
+}
+
+BaseScreen* ScreenManager::GetTopmostScreen() {
+  DCHECK(!screen_stack_.empty());
+  return FindOrCreateScreen(screen_stack_.top());
+}
+
+void ScreenManager::OnDisplayIsReady() {
+  js_is_ready_ = true;
+  ShowScreenImpl(
+      start_screen_,
+      start_screen_params_.release(),
+      start_screen_popup_);
+}
+
+BaseScreen* ScreenManager::FindOrCreateScreen(const std::string& id) {
+  ScreenMap::iterator i = existing_screens_.find(id);
+  if (i != existing_screens_.end())
+    return i->second.get();
+  BaseScreen* result = factory_->CreateScreen(id);
+  existing_screens_[id] = linked_ptr<BaseScreen>(result);
+  return result;
+}
+
+void ScreenManager::TearDownTopmostScreen() {
+  DCHECK(!screen_stack_.empty());
+  std::string screen_id = screen_stack_.top();
+
+  ScreenMap::iterator i = existing_screens_.find(screen_id);
+
+  if (i == existing_screens_.end()) {
+    NOTREACHED();
+    return;
+  }
+  BaseScreen* screen = i->second.get();
+  if (!screen->IsPermanent()) {
+    screen->OnClose();
+    existing_screens_.erase(i);
+  }
+}
+
+void ScreenManager::SetScreenFlow(ScreenFlow* flow) {
+  if (flow)
+    flow->set_screen_manager(this);
+  // TODO(antrim): delayed reset.
+  flow_.reset(flow);
+}
+
+}  // namespace chromeos
diff --git a/chrome/browser/chromeos/login/screens/screen_manager.h b/chrome/browser/chromeos/login/screens/screen_manager.h
new file mode 100644
index 0000000..11774c8
--- /dev/null
+++ b/chrome/browser/chromeos/login/screens/screen_manager.h
@@ -0,0 +1,112 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_SCREEN_MANAGER_H_
+#define CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_SCREEN_MANAGER_H_
+
+#include <map>
+#include <stack>
+#include <string>
+
+#include "base/memory/linked_ptr.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+
+namespace chromeos {
+
+class BaseScreen;
+class OobeDisplay;
+class ScreenContext;
+class ScreenFactory;
+class ScreenFlow;
+
+// Class that manages screen states and flow.
+// TODO(antrim): add implementation details comments.
+class ScreenManager {
+ public:
+  ScreenManager(ScreenFactory* factory,
+                OobeDisplay* oobe_display,
+                ScreenFlow* initial_flow);
+  virtual ~ScreenManager();
+
+  // Creates and initializes screen, without showing it.
+  void WarmupScreen(const std::string& id,
+                    ScreenContext* context);
+
+  // Creates, initializes and shows a screen identified by |id|.
+  // Should be called when no popup screens are displayed.
+  // Closes the previous screen.
+  void ShowScreen(const std::string& id);
+
+  // Creates, initializes with |context| and shows a screen identified by |id|.
+  // Should be called when no popup screens are displayed.
+  // Closes the previous screen.
+  void ShowScreenWithParameters(const std::string& id,
+                                ScreenContext* context);
+
+  // Creates, initializes and shows a popup screen identified by |id|.
+  void PopupScreen(const std::string& id);
+
+  // Creates, initializes with |context| and shows a popup screen identified
+  // by |id|.
+  void PopupScreenWithParameters(const std::string& id,
+                                 ScreenContext* context);
+
+  // Hides the popup screen identified by |screen_id|.
+  void HidePopupScreen(const std::string& screen_id);
+
+  std::string GetCurrentScreenId();
+
+  // Sets new screen flow.
+  void SetScreenFlow(ScreenFlow* flow);
+
+ private:
+  void ShowScreenImpl(const std::string& id,
+                      ScreenContext* context,
+                      bool isPopup);
+  void TransitionScreen(const std::string& from_id,
+                        const std::string& to_id);
+
+  void TearDownTopmostScreen();
+
+  void OnDisplayIsReady();
+
+  BaseScreen* GetTopmostScreen();
+  BaseScreen* FindOrCreateScreen(const std::string& id);
+
+  typedef std::map<std::string, linked_ptr<BaseScreen> > ScreenMap;
+
+  // Factory of screens.
+  scoped_ptr<ScreenFactory> factory_;
+
+  // Root of all screen handlers.
+  OobeDisplay* display_;
+
+  // Current screen flow.
+  scoped_ptr<ScreenFlow> flow_;
+
+  base::WeakPtrFactory<ScreenManager> weak_factory_;
+
+  // Map of existing screens. All screen instances are owned by screen manager.
+  ScreenMap existing_screens_;
+
+  // Current stack of screens (screen ids, all screens are assumed to have an
+  // instance in |existing_screens_|. Only topmost screen is visible.
+  std::stack<std::string> screen_stack_;
+
+  // Flag that indicates if JS counterpart is fully initialized.
+  bool js_is_ready_;
+
+  // Capture of parameters for ShowScreen() if it was called before JS
+  // counterpart is fully initialized.
+  std::string start_screen_;
+  scoped_ptr<ScreenContext> start_screen_params_;
+  bool start_screen_popup_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScreenManager);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_SCREEN_MANAGER_H_
diff --git a/chrome/browser/chromeos/login/screens/wizard_screen.h b/chrome/browser/chromeos/login/screens/wizard_screen.h
index eca47a7..953cd82 100644
--- a/chrome/browser/chromeos/login/screens/wizard_screen.h
+++ b/chrome/browser/chromeos/login/screens/wizard_screen.h
@@ -8,28 +8,18 @@
 #include <string>
 
 #include "base/gtest_prod_util.h"
+#include "chrome/browser/chromeos/login/screens/base_screen.h"
 
 namespace chromeos {
 
 class ScreenObserver;
 
 // Base class for the OOBE screens.
-class WizardScreen {
+class WizardScreen : public BaseScreen {
  public:
   explicit WizardScreen(ScreenObserver* screen_observer);
   virtual ~WizardScreen() {}
 
-  // Called before showing the screen. It is the right moment for the
-  // screen's actor to pass the information to the corresponding OobeDisplay.
-  virtual void PrepareToShow() = 0;
-  // Makes wizard screen visible.
-  virtual void Show() = 0;
-  // Makes wizard screen invisible.
-  virtual void Hide() = 0;
-
-  // Returns the screen name.
-  virtual std::string GetName() const = 0;
-
  protected:
   ScreenObserver* get_screen_observer() const {
     return screen_observer_;
diff --git a/chrome/browser/ui/webui/chromeos/login/oobe_ui.cc b/chrome/browser/ui/webui/chromeos/login/oobe_ui.cc
index 3535f2e..39357e3 100644
--- a/chrome/browser/ui/webui/chromeos/login/oobe_ui.cc
+++ b/chrome/browser/ui/webui/chromeos/login/oobe_ui.cc
@@ -140,7 +140,8 @@ OobeUI::OobeUI(content::WebUI* web_ui)
       terms_of_service_screen_actor_(NULL),
       user_image_screen_actor_(NULL),
       kiosk_app_menu_handler_(NULL),
-      current_screen_(SCREEN_UNKNOWN) {
+      current_screen_(SCREEN_UNKNOWN),
+      ready_(false) {
   InitializeScreenMaps();
 
   network_state_informer_ = new NetworkStateInformer();
@@ -278,11 +279,6 @@ ErrorScreenActor* OobeUI::GetErrorScreenActor() {
   return error_screen_handler_;
 }
 
-ViewScreenDelegate* OobeUI::GetRegistrationScreenActor() {
-  NOTIMPLEMENTED();
-  return NULL;
-}
-
 LocallyManagedUserCreationScreenHandler*
     OobeUI::GetLocallyManagedUserCreationScreenActor() {
   return locally_managed_user_creation_screen_actor_;
@@ -362,10 +358,21 @@ void OobeUI::AddScreenHandler(BaseScreenHandler* handler) {
 }
 
 void OobeUI::InitializeHandlers() {
+  ready_ = true;
+  for (size_t i = 0; i < ready_callbacks_.size(); ++i)
+    ready_callbacks_[i].Run();
+  ready_callbacks_.clear();
+
   for (size_t i = 0; i < handlers_.size(); ++i)
     handlers_[i]->InitializeBase();
 }
 
+bool OobeUI::IsJSReady(const base::Closure& display_is_ready_callback) {
+  if (!ready_)
+    ready_callbacks_.push_back(display_is_ready_callback);
+  return ready_;
+}
+
 void OobeUI::ShowOobeUI(bool show) {
   core_handler_->ShowOobeUI(show);
 }
diff --git a/chrome/browser/ui/webui/chromeos/login/oobe_ui.h b/chrome/browser/ui/webui/chromeos/login/oobe_ui.h
index 360c457..e8c586e 100644
--- a/chrome/browser/ui/webui/chromeos/login/oobe_ui.h
+++ b/chrome/browser/ui/webui/chromeos/login/oobe_ui.h
@@ -72,10 +72,11 @@ class OobeUI : public OobeDisplay,
       GetTermsOfServiceScreenActor() OVERRIDE;
   virtual UserImageScreenActor* GetUserImageScreenActor() OVERRIDE;
   virtual ErrorScreenActor* GetErrorScreenActor() OVERRIDE;
-  virtual ViewScreenDelegate* GetRegistrationScreenActor() OVERRIDE;
   virtual WrongHWIDScreenActor* GetWrongHWIDScreenActor() OVERRIDE;
   virtual LocallyManagedUserCreationScreenHandler*
       GetLocallyManagedUserCreationScreenActor() OVERRIDE;
+  virtual bool IsJSReady(const base::Closure& display_is_ready_callback)
+      OVERRIDE;
 
   // Collects localized strings from the owned handlers.
   void GetLocalizedStrings(base::DictionaryValue* localized_strings);
@@ -152,6 +153,13 @@ class OobeUI : public OobeDisplay,
   // Maps screen ids to JS screen names.
   std::vector<std::string> screen_names_;
 
+  // Flag that indicates whether JS part is fully loaded and ready to accept
+  // calls.
+  bool ready_;
+
+  // Callbacks to notify when JS part is fully loaded and ready to accept calls.
+  std::vector<base::Closure> ready_callbacks_;
+
   DISALLOW_COPY_AND_ASSIGN(OobeUI);
 };
 
diff --git a/chrome/chrome_browser_chromeos.gypi b/chrome/chrome_browser_chromeos.gypi
index 9b05191..18b6efa 100644
--- a/chrome/chrome_browser_chromeos.gypi
+++ b/chrome/chrome_browser_chromeos.gypi
@@ -455,6 +455,8 @@
         'browser/chromeos/login/screen_locker.h',
         'browser/chromeos/login/screen_locker_delegate.cc',
         'browser/chromeos/login/screen_locker_delegate.h',
+        'browser/chromeos/login/screens/base_screen.cc',
+        'browser/chromeos/login/screens/base_screen.h',
         'browser/chromeos/login/screens/error_screen.cc',
         'browser/chromeos/login/screens/error_screen.h',
         'browser/chromeos/login/screens/error_screen_actor.cc',
@@ -468,6 +470,12 @@
         'browser/chromeos/login/screens/reset_screen.cc',
         'browser/chromeos/login/screens/reset_screen.h',
         'browser/chromeos/login/screens/reset_screen_actor.h',
+        'browser/chromeos/login/screens/screen_context.h',
+        'browser/chromeos/login/screens/screen_factory.cc',
+        'browser/chromeos/login/screens/screen_factory.h',
+        'browser/chromeos/login/screens/screen_flow.h',
+        'browser/chromeos/login/screens/screen_manager.cc',
+        'browser/chromeos/login/screens/screen_manager.h',
         'browser/chromeos/login/screens/screen_observer.h',
         'browser/chromeos/login/screens/terms_of_service_screen.cc',
         'browser/chromeos/login/screens/terms_of_service_screen.h',