Put back 53641 - Landing OEM customization CL for Denis...

chrome/browser/chromeos/login/wizard_controller.cc

 // Copyright (c) 2010 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/wizard_controller.h"
 
 #include <gdk/gdk.h>
 #include <signal.h>
 #include <sys/types.h>
 
 #include <string>
 #include <vector>
 
 #include "app/l10n_util.h"
+#include "app/resource_bundle.h"
 #include "base/command_line.h"
 #include "base/logging.h"
+#include "base/file_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/login_library.h"
 #include "chrome/browser/chromeos/cros/system_library.h"
 #include "chrome/browser/chromeos/customization_document.h"
 #include "chrome/browser/chromeos/input_method/input_method_util.h"
 #include "chrome/browser/chromeos/login/account_screen.h"
 #include "chrome/browser/chromeos/login/background_view.h"
 #include "chrome/browser/chromeos/login/eula_view.h"
 #include "chrome/browser/chromeos/login/existing_user_controller.h"
@@ skipping 17 matching lines @@
 #include "views/accelerator.h"
 #include "views/painter.h"
 #include "views/view.h"
 #include "views/widget/widget_gtk.h"
 
 namespace {
 
 // A boolean pref of the OOBE complete flag.
 const wchar_t kOobeComplete[] = L"OobeComplete";
 
+// Path to OEM partner startup customization manifest.
+const char kStartupCustomizationManifestPath[] =
+    "/mnt/partner_partition/etc/chromeos/startup_manifest.json";
+
+// URL where to fetch OEM services customization manifest from.
+// TODO(denisromanov): Change this to real URL when it becomes available.
+const char kServicesCustomizationManifestUrl[] =
+    "file:///mnt/partner_partition/etc/chromeos/services_manifest.json";
+
+// Path to flag file indicating that OOBE was completed successfully.
+const char kOobeCompleteFlagFilePath[] =
+    "/home/chronos/.oobe_completed";
+
 // Default size of the OOBE screen.
 const int kWizardScreenWidth = 700;
 const int kWizardScreenHeight = 416;
 
 // RootView of the Widget WizardController creates. Contains the contents of the
 // WizardController.
 class ContentView : public views::View {
  public:
   ContentView(int window_x, int window_y, int screen_w, int screen_h)
       : window_x_(window_x),
@@ skipping 91 matching lines @@
   delete controller;
   // Launch browser after controller is deleted and its windows are closed.
   chromeos::LoginUtils::Get()->EnableBrowserLaunch(true);
   ChromeThread::PostTask(
       ChromeThread::UI,
       FROM_HERE,
       NewRunnableFunction(&chromeos::LoginUtils::DoBrowserLaunch,
                           ProfileManager::GetDefaultProfile()));
 }
 
+void DeleteWizardControllerAndApplyCustomization(WizardController* controller) {
+  controller->ApplyPartnerServicesCustomizations();
+  delete controller;
+}
+
 }  // namespace
 
 const char WizardController::kNetworkScreenName[] = "network";
 const char WizardController::kLoginScreenName[] = "login";
 const char WizardController::kAccountScreenName[] = "account";
 const char WizardController::kUpdateScreenName[] = "update";
 const char WizardController::kUserImageScreenName[] = "image";
 const char WizardController::kEulaScreenName[] = "eula";
 const char WizardController::kRegistrationScreenName[] = "register";
 
@@ skipping 55 matching lines @@
   // stream). Hence enabling double buffer.
   window->EnableDoubleBuffer(true);
   window->Init(NULL, gfx::Rect(window_x, window_y, kWizardScreenWidth,
                                kWizardScreenHeight));
   chromeos::WmIpc::instance()->SetWindowType(
       window->GetNativeView(),
       chromeos::WM_IPC_WINDOW_LOGIN_GUEST,
       NULL);
   window->SetContentsView(contents_);
 
-  bool oobe_complete = IsOobeComplete();
+  bool oobe_complete = IsOobeCompleted();
 
   if (!oobe_complete || first_screen_name == kOutOfBoxScreenName) {
     is_out_of_box_ = true;
   }
 
   ShowFirstScreen(first_screen_name);
 
   // This keeps the window from flashing at startup.
   GdkWindow* gdk_window = window->GetNativeView()->window;
   gdk_window_set_back_pixmap(gdk_window, NULL, false);
@@ skipping 82 matching lines @@
         chromeos::UserManager::Get()->GetUsers();
     // ExistingUserController deletes itself.
     gfx::Rect screen_bounds;
     background_widget_->GetBounds(&screen_bounds, true);
     chromeos::ExistingUserController* controller =
         new chromeos::ExistingUserController(users, screen_bounds);
     controller->OwnBackground(background_widget_, background_view_);
     controller->Init();
     background_widget_ = NULL;
     background_view_ = NULL;
-    MessageLoop::current()->DeleteSoon(FROM_HERE, this);
+
+    FilePath startup_manifest_path(kStartupCustomizationManifestPath);
+    if (file_util::PathExists(startup_manifest_path)) {
+      services_manifest_fetcher_.reset(new StringFetcher(
+          kServicesCustomizationManifestUrl));
+    }
+    ChromeThread::PostTask(
+        ChromeThread::UI,
+        FROM_HERE,
+        NewRunnableFunction(&DeleteWizardControllerAndApplyCustomization,
+                            this));
+
     return;
   }
 
   SetCurrentScreen(GetLoginScreen());
 }
 
 void WizardController::ShowAccountScreen() {
   SetStatusAreaVisible(true);
   SetCurrentScreen(GetAccountScreen());
 }
@@ skipping 89 matching lines @@
 }
 
 void WizardController::OnAccountCreated() {
   ShowLoginScreen();
   chromeos::LoginScreen* login = GetLoginScreen();
   if (!username_.empty()) {
     login->view()->SetUsername(username_);
     if (!password_.empty()) {
       login->view()->SetPassword(password_);
       // TODO(dpolukhin): clear password memory for real. Now it is not
-      // a problem becuase we can't extract password from the form.
+      // a problem because we can't extract password from the form.
       password_.clear();
       login->view()->Login();
     }
   }
 }
 
 void WizardController::OnConnectionFailed() {
   // TODO(dpolukhin): show error message after login screen is displayed.
   ShowLoginScreen();
 }
@@ skipping 35 matching lines @@
       NewRunnableFunction(&DeleteWizardControllerAndLaunchBrowser,
                           this));
   // TODO(avayvod): Sync image with Google Sync.
 }
 
 void WizardController::OnUserImageSkipped() {
   OnUserImageSelected();
 }
 
 void WizardController::OnRegistrationSuccess() {
+  MarkDeviceRegistered();
   // TODO(nkostylev): Registration screen should be shown on first sign in.
   ShowLoginScreen();
 }
 
 void WizardController::OnRegistrationSkipped() {
   // TODO(nkostylev): Track in a histogram?
   OnRegistrationSuccess();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 45 matching lines @@
   }
 }
 
 void WizardController::MarkOobeCompleted() {
   PrefService* prefs = g_browser_process->local_state();
   prefs->SetBoolean(kOobeComplete, true);
   // Make sure that changes are reflected immediately.
   prefs->SavePersistentPrefs();
 }
 
+void WizardController::MarkDeviceRegistered() {
+  // Create flag file for boot-time init scripts.
+  FilePath oobe_complete_path(kOobeCompleteFlagFilePath);
+  FILE* oobe_flag_file = file_util::OpenFile(oobe_complete_path, "w+b");
+  DCHECK(oobe_flag_file != NULL) << kOobeCompleteFlagFilePath;
+  if (oobe_flag_file != NULL)
+    file_util::CloseFile(oobe_flag_file);
+}
+
+void WizardController::ApplyPartnerServicesCustomizations() {
+  if (services_manifest_fetcher_.get() == NULL ||
+      services_manifest_fetcher_->result().empty()) {
+    return;
+  }
+  scoped_ptr<chromeos::ServicesCustomizationDocument> customization;
+  bool manifest_loaded;
+  customization.reset(new chromeos::ServicesCustomizationDocument());
+  manifest_loaded = customization->LoadManifestFromString(
+      services_manifest_fetcher_->result());
+  DCHECK(manifest_loaded) << "Customization manifest fetch error: "
+                          << services_manifest_fetcher_->result();
+  if (!manifest_loaded)
+    return;
+  LOG(INFO) << "partner services customizations manifest loaded successfully";
+  if (!customization->initial_start_page_url().empty()) {
+    // Append partner's start page url to command line so it gets opened
+    // on browser startup.
+    CommandLine::ForCurrentProcess()->AppendLooseValue(
+        UTF8ToWide(customization->initial_start_page_url()));
+    LOG(INFO) << "initial_start_page_url: "
+              << customization->initial_start_page_url();
+  }
+  // TODO(dpolukhin): apply customized apps, exts and support page.
+  MarkDeviceRegistered();
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // WizardController, chromeos::ScreenObserver overrides:
 void WizardController::OnExit(ExitCodes exit_code) {
   switch (exit_code) {
     case LOGIN_SIGN_IN_SELECTED:
       OnLoginSignInSelected();
       break;
     case LOGIN_GUEST_SELECTED:
       OnLoginGuestUser();
       break;
@@ skipping 48 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 // WizardController, WizardScreen overrides:
 views::View* WizardController::GetWizardView() {
   return contents_;
 }
 
 chromeos::ScreenObserver* WizardController::GetObserver(WizardScreen* screen) {
   return observer_ ? observer_ : this;
 }
 
-bool WizardController::IsOobeComplete() {
+bool WizardController::IsOobeCompleted() {
   return g_browser_process->local_state()->GetBoolean(kOobeComplete);
 }
 
+bool WizardController::IsDeviceRegistered() {
+  FilePath oobe_complete_flag_file_path(kOobeCompleteFlagFilePath);
+  return file_util::PathExists(oobe_complete_flag_file_path);
+}
+
 namespace browser {
 
 // Declared in browser_dialogs.h so that others don't need to depend on our .h.
 void ShowLoginWizard(const std::string& first_screen_name,
                      const gfx::Size& size) {
   LOG(INFO) << "showing login screen: " << first_screen_name;
 
   // Tell the window manager that the user isn't logged in.
   chromeos::WmIpc::instance()->SetLoggedInProperty(false);
 
   // Set up keyboards. For example, when |locale| is "en-US", enable US qwerty
   // and US dvorak keyboard layouts.
   if (g_browser_process && g_browser_process->local_state()) {
     const std::string locale = g_browser_process->GetApplicationLocale();
     const std::string initial_input_method_id =
         g_browser_process->local_state()->GetString(
             chromeos::kPreferredKeyboardLayout);
     chromeos::input_method::EnableInputMethods(
         locale, chromeos::input_method::kKeyboardLayoutsOnly,
         initial_input_method_id);
   }
 
   gfx::Rect screen_bounds(chromeos::CalculateScreenBounds(size));
 
   // Check whether we need to execute OOBE process.
-  bool oobe_complete = WizardController::IsOobeComplete();
+  bool oobe_complete = WizardController::IsOobeCompleted();
 
   if (first_screen_name.empty() &&
       oobe_complete &&
       chromeos::CrosLibrary::Get()->EnsureLoaded() &&
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableLoginImages)) {
     std::vector<chromeos::UserManager::User> users =
         chromeos::UserManager::Get()->GetUsers();
     // ExistingUserController deletes itself.
     (new chromeos::ExistingUserController(users, screen_bounds))->Init();
     return;
   }
 
-  scoped_ptr<chromeos::StartupCustomizationDocument> customization;
-
-  if (!oobe_complete) {
-    // Load partner customization startup manifest if needed.
-    if (CommandLine::ForCurrentProcess()->HasSwitch(
-        switches::kStartupManifest)) {
-      customization.reset(new chromeos::StartupCustomizationDocument());
-      FilePath manifest_path =
-          CommandLine::ForCurrentProcess()->GetSwitchValuePath(
-              switches::kStartupManifest);
-      bool manifest_loaded = customization->LoadManifestFromFile(manifest_path);
-      DCHECK(manifest_loaded) << manifest_path.value();
-    }
-
-    // Do UX customizations if needed.
-    if (customization != NULL) {
-      // Switch to initial locale if specified by customization.
-      const std::string locale = customization->initial_locale();
-      if (!locale.empty()) {
-        chromeos::LanguageSwitchMenu::SwitchLanguage(locale);
-      }
-
-      // Set initial timezone if specified by customization.
-      const std::string timezone_name = customization->initial_timezone();
-      if (!timezone_name.empty()) {
-        icu::TimeZone* timezone = icu::TimeZone::createTimeZone(
-            icu::UnicodeString::fromUTF8(timezone_name));
-        chromeos::CrosLibrary::Get()->GetSystemLibrary()->SetTimezone(timezone);
-      }
-    }
-  }
-
   // Create and show the wizard.
   WizardController* controller = new WizardController();
-  if (!oobe_complete)
-    controller->SetCustomization(customization.release());
+
+  // Load partner customization startup manifest if it is available.
+  FilePath startup_manifest_path(kStartupCustomizationManifestPath);
+  std::string locale;
+  if (file_util::PathExists(startup_manifest_path)) {
+    scoped_ptr<chromeos::StartupCustomizationDocument> customization(
+        new chromeos::StartupCustomizationDocument());
+    bool manifest_loaded = customization->LoadManifestFromFile(
+        FilePath(kStartupCustomizationManifestPath));
+    DCHECK(manifest_loaded) << kStartupCustomizationManifestPath;
+    if (manifest_loaded) {
+      LOG(INFO) << "startup manifest loaded successfully";
+      // Switch to initial locale if specified by customization
+      // and has not been set yet. We cannot call
+      // chromeos::LanguageSwitchMenu::SwitchLanguage here before
+      // EmitLoginPromptReady.
+      const std::string current_locale =
+          g_browser_process->local_state()->GetString(
+              prefs::kApplicationLocale);
+      LOG(INFO) << "current locale: " << current_locale;
+      if (current_locale.empty()) {
+        locale = customization->initial_locale();
+        LOG(INFO) << "initial locale: " << locale;
+        if (!locale.empty()) {
+          ResourceBundle::ReloadSharedInstance(UTF8ToWide(locale));
+        }
+      }
+
+      controller->SetCustomization(customization.release());
+    }
+  }
+
   controller->ShowBackground(screen_bounds);
   controller->Init(first_screen_name, screen_bounds);
   controller->Show();
+
   if (chromeos::CrosLibrary::Get()->EnsureLoaded())
     chromeos::CrosLibrary::Get()->GetLoginLibrary()->EmitLoginPromptReady();
+
+  if (controller->GetCustomization() != NULL) {
+    if (!locale.empty())
+      chromeos::LanguageSwitchMenu::SwitchLanguage(locale);
+
+    // Set initial timezone if specified by customization.
+    const std::string timezone_name =
+        controller->GetCustomization()->initial_timezone();
+    LOG(INFO) << "initial time zone: " << timezone_name;
+    if (!timezone_name.empty()) {
+      icu::TimeZone* timezone = icu::TimeZone::createTimeZone(
+          icu::UnicodeString::fromUTF8(timezone_name));
+      chromeos::CrosLibrary::Get()->GetSystemLibrary()->SetTimezone(timezone);
+    }
+  }
 }
 
 }  // namespace browser