Home | History | Annotate | Download | only in screens 
      1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/chromeos/login/screens/screen_manager.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/logging.h"
      9 #include "chrome/browser/chromeos/login/oobe_display.h"
     10 #include "chrome/browser/chromeos/login/screens/base_screen.h"
     11 #include "chrome/browser/chromeos/login/screens/screen_factory.h"
     12 #include "chrome/browser/chromeos/login/screens/screen_flow.h"
     13 
     14 namespace chromeos {
     15 
     16 ScreenManager::ScreenManager(ScreenFactory* factory,
     17                              OobeDisplay* oobe_display,
     18                              ScreenFlow* initial_flow)
     19     : factory_(factory),
     20       display_(oobe_display),
     21       flow_(initial_flow),
     22       weak_factory_(this) {
     23   js_is_ready_ = display_->IsJSReady(
     24       base::Bind(&ScreenManager::OnDisplayIsReady, weak_factory_.GetWeakPtr()));
     25 
     26   // TODO({antrim|ygorshenin}@): register ScreenManager as delegate in
     27   // ScreenManagerHandler instance.
     28 }
     29 
     30 ScreenManager::~ScreenManager() {
     31 }
     32 
     33 void ScreenManager::WarmupScreen(const std::string& id,
     34                                  ScreenContext* context) {
     35 
     36 }
     37 
     38 void ScreenManager::ShowScreen(const std::string& id) {
     39   ShowScreenImpl(id, new ScreenContext(), false);
     40 }
     41 
     42 void ScreenManager::ShowScreenWithParameters(const std::string& id,
     43                                              ScreenContext* context) {
     44   ShowScreenImpl(id, context, false);
     45 }
     46 
     47 void ScreenManager::PopupScreen(const std::string& id) {
     48   ShowScreenImpl(id, new ScreenContext(), true);
     49 }
     50 
     51 void ScreenManager::PopupScreenWithParameters(const std::string& id,
     52                                               ScreenContext* context) {
     53   ShowScreenImpl(id, context, true);
     54 }
     55 
     56 void ScreenManager::HidePopupScreen(const std::string& screen_id) {
     57   DCHECK(!screen_stack_.empty());
     58   DCHECK_EQ(screen_stack_.top(), screen_id);
     59 
     60   // TODO(antrim): check that id really exist in stack.
     61   std::string previous_screen = GetCurrentScreenId();
     62   GetTopmostScreen()->OnHide();
     63   TearDownTopmostScreen();
     64   screen_stack_.pop();
     65 
     66   std::string screen_below;
     67   if (!screen_stack_.empty()) {
     68     screen_below = GetCurrentScreenId();
     69     GetTopmostScreen()->OnShow();
     70   }
     71   TransitionScreen(previous_screen, screen_below);
     72 }
     73 
     74 std::string ScreenManager::GetCurrentScreenId() {
     75   DCHECK(!screen_stack_.empty());
     76   return screen_stack_.top();
     77 }
     78 
     79 void ScreenManager::SetScreenFlow(ScreenFlow* flow) {
     80   if (flow)
     81     flow->set_screen_manager(this);
     82   // TODO(antrim): delayed reset.
     83   flow_.reset(flow);
     84 }
     85 
     86 void ScreenManager::ShowScreenImpl(const std::string& id,
     87                                    ScreenContext* context,
     88                                    bool popup) {
     89   if (!js_is_ready_) {
     90     DCHECK(!start_screen_params_.get());
     91     start_screen_params_.reset(context);
     92     start_screen_popup_ = popup;
     93     start_screen_ = id;
     94     return;
     95   }
     96   DCHECK(popup || screen_stack_.size() <= 1);
     97   BaseScreen* screen = FindOrCreateScreen(id);
     98   screen->SetContext(context);
     99   screen->Initialize(context);
    100 
    101   std::string previous_screen;
    102   if (!screen_stack_.empty()) {
    103     previous_screen = GetCurrentScreenId();
    104     GetTopmostScreen()->OnHide();
    105     if (!popup)
    106       TearDownTopmostScreen();
    107   }
    108 
    109   DCHECK(popup || screen_stack_.empty());
    110   screen_stack_.push(id);
    111   screen->OnShow();
    112   TransitionScreen(previous_screen, id);
    113 }
    114 
    115 void ScreenManager::TransitionScreen(const std::string& from_id,
    116                                      const std::string& to_id) {
    117 }
    118 
    119 void ScreenManager::TearDownTopmostScreen() {
    120   DCHECK(!screen_stack_.empty());
    121   std::string screen_id = screen_stack_.top();
    122 
    123   ScreenMap::iterator i = existing_screens_.find(screen_id);
    124 
    125   if (i == existing_screens_.end()) {
    126     NOTREACHED();
    127     return;
    128   }
    129   BaseScreen* screen = i->second.get();
    130   if (!screen->IsPermanent()) {
    131     screen->OnClose();
    132     existing_screens_.erase(i);
    133   }
    134 }
    135 
    136 void ScreenManager::OnDisplayIsReady() {
    137   js_is_ready_ = true;
    138   ShowScreenImpl(
    139       start_screen_,
    140       start_screen_params_.release(),
    141       start_screen_popup_);
    142 }
    143 
    144 BaseScreen* ScreenManager::GetTopmostScreen() {
    145   DCHECK(!screen_stack_.empty());
    146   return FindOrCreateScreen(screen_stack_.top());
    147 }
    148 
    149 BaseScreen* ScreenManager::FindOrCreateScreen(const std::string& id) {
    150   ScreenMap::iterator i = existing_screens_.find(id);
    151   if (i != existing_screens_.end())
    152     return i->second.get();
    153   BaseScreen* result = factory_->CreateScreen(id);
    154   existing_screens_[id] = linked_ptr<BaseScreen>(result);
    155   return result;
    156 }
    157 
    158 void ScreenManager::OnButtonPressed(const std::string& screen_name,
    159                                     const std::string& button_id) {
    160   CallOnScreen<const std::string&>(screen_name,
    161                                    &BaseScreen::OnButtonPressed,
    162                                    button_id);
    163 }
    164 
    165 void ScreenManager::OnContextChanged(const std::string& screen_name,
    166                                      const base::DictionaryValue* diff) {
    167   CallOnScreen<const base::DictionaryValue*>(screen_name,
    168                                              &BaseScreen::OnContextChanged,
    169                                              diff);
    170 }
    171 
    172 }  // namespace chromeos
    173