Fix of "login is not defined" error in OOBE

chrome/browser/ui/webui/chromeos/login/base_screen_handler.h

 // 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_UI_WEBUI_CHROMEOS_LOGIN_BASE_SCREEN_HANDLER_H_
 #define CHROME_BROWSER_UI_WEBUI_CHROMEOS_LOGIN_BASE_SCREEN_HANDLER_H_
 
 #include <string>
 
 #include "base/bind.h"
@@ skipping 14 matching lines @@
 
 namespace login {
 class LocalizedValuesBuilder;
 }
 
 namespace chromeos {
 
 class BaseScreen;
 class OobeUI;
 
+// A helper class to store deferred Javascript calls, shared by subclasses of
+// BaseScreenHandler.
+class JSCallsContainer {
+ public:
+  JSCallsContainer();
+  ~JSCallsContainer();
+
+  // Used to decide whether the JS call should be deferred.
+  bool is_initialized() { return is_initialized_; }
+
+  // Used to mark the instance as intialized.
+  void mark_initialized() { is_initialized_ = true; }
+
+  // Used to add deferred calls to.
+  std::vector<base::Closure>& deferred_js_calls() { return deferred_js_calls_; }
+
+ private:
+  // Whether the instance is initialized.
+  //
+  // The instance becomes initialized after the corresponding message is
+  // received from Javascript side.
+  bool is_initialized_ = false;
+
+  // Javascript calls that have been deferred while the instance was not
+  // initialized yet.
+  std::vector<base::Closure> deferred_js_calls_;
+};
+
 // Base class for the OOBE/Login WebUI handlers.
 class BaseScreenHandler : public content::WebUIMessageHandler,
                           public ModelViewChannel {
  public:
   BaseScreenHandler();
+  explicit BaseScreenHandler(JSCallsContainer* js_calls_container);
   ~BaseScreenHandler() override;
 
   // Gets localized strings to be used on the page.
   void GetLocalizedStrings(
       base::DictionaryValue* localized_strings);
 
   // WebUIMessageHandler implementation:
   void RegisterMessages() override;
 
   // ModelViewChannel implementation:
@@ skipping 65 matching lines @@
               const A1& arg1,
               const A2& arg2,
               const A3& arg3,
               const A4& arg4) {
     web_ui()->CallJavascriptFunctionUnsafe(
         FullMethodPath(method), ::login::MakeValue(arg1),
         ::login::MakeValue(arg2), ::login::MakeValue(arg3),
         ::login::MakeValue(arg4));
   }
 
+  template <typename... Args>
+  void CallJSOrDefer(const std::string& function_name, const Args&... args) {
+    DCHECK(js_calls_container_);
+    if (js_calls_container_->is_initialized()) {
+      CallJS(function_name, args...);
+    } else {
+      // Note that std::conditional is used here in order to obtain a sequence
+      // of base::Value types with the length equal to sizeof...(Args); the C++
+      // template parameter pack expansion rules require that the name of the
+      // parameter pack appears in the pattern, even though the elements of the
+      // Args pack are not actually in this code.
+      js_calls_container_->deferred_js_calls().push_back(base::Bind(
+          &BaseScreenHandler::ExecuteDeferredJSCall<
+              typename std::conditional<true, base::Value, Args>::type...>,
+          base::Unretained(this), function_name,
+          base::Passed(::login::MakeValue(args).CreateDeepCopy())...));
+    }
+  }
+
+  // Executes Javascript calls that were deferred while the instance was not
+  // initialized yet.
+  void ExecuteDeferredJSCalls();
+
   // Shortcut methods for adding WebUI callbacks.
   template<typename T>
   void AddRawCallback(const std::string& name,
                       void (T::*method)(const base::ListValue* args)) {
     web_ui()->RegisterMessageCallback(
         name,
         base::Bind(method, base::Unretained(static_cast<T*>(this))));
   }
 
   template<typename T, typename... Args>
@@ skipping 27 matching lines @@
 
   // Whether page is ready.
   bool page_is_ready() const { return page_is_ready_; }
 
   // Returns the window which shows us.
   virtual gfx::NativeWindow GetNativeWindow();
 
   void SetBaseScreen(BaseScreen* base_screen);
 
  private:
+  // Calls Javascript method.
+  //
+  // Note that the Args template parameter pack should consist of types
+  // convertible to base::Value.
+  template <typename... Args>
+  void ExecuteDeferredJSCall(const std::string& function_name,
+                             std::unique_ptr<Args>... args) {
+    CallJS(function_name, *args...);
+  }
+
   // Returns full name of JS method based on screen and method
   // names.
   std::string FullMethodPath(const std::string& method) const;
 
   // Handles user action.
   void HandleUserAction(const std::string& action_id);
 
   // Handles situation when screen context is changed.
   void HandleContextChanged(const base::DictionaryValue* diff);
 
   // Keeps whether page is ready.
   bool page_is_ready_ = false;
 
   BaseScreen* base_screen_ = nullptr;
 
   // Full name of the corresponding JS screen object. Can be empty, if
   // there are no corresponding screen object or several different
   // objects.
   std::string js_screen_path_prefix_;
 
   // The string id used in the async asset load in JS. If it is set to a
   // non empty value, the Initialize will be deferred until the underlying load
   // is finished.
   std::string async_assets_load_id_;
 
   // Pending changes to context which will be sent when the page will be ready.
   base::DictionaryValue pending_context_changes_;
 
+  JSCallsContainer* js_calls_container_ = nullptr;  // non-owning pointers.
+
   DISALLOW_COPY_AND_ASSIGN(BaseScreenHandler);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_UI_WEBUI_CHROMEOS_LOGIN_BASE_SCREEN_HANDLER_H_