Chrome-side lockbox bindings

chrome/browser/chromeos/login/enterprise_enrollment_view.cc

 // 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/enterprise_enrollment_view.h"
 
 #include "base/json/json_writer.h"
 #include "base/values.h"
+#include "chrome/browser/chromeos/cros/cros_library.h"
+#include "chrome/browser/chromeos/cros/cryptohome_library.h"
 #include "chrome/browser/chromeos/login/enterprise_enrollment_screen.h"
 #include "chrome/browser/chromeos/login/helper.h"
 #include "chrome/browser/chromeos/login/rounded_rect_painter.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/webui/chromeos/enterprise_enrollment_ui.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/site_instance.h"
 #include "content/browser/tab_contents/tab_contents_delegate.h"
 #include "grit/generated_resources.h"
@@ skipping 49 matching lines @@
       NavigationType::Type navigation_type) {
     return false;
   }
   virtual void MoveContents(TabContents* source, const gfx::Rect& pos) {}
   virtual void ToolbarSizeChanged(TabContents* source, bool is_animating) {}
   virtual bool HandleContextMenu(const ContextMenuParams& params) {
     return true;
   }
 
  private:
+
   DISALLOW_COPY_AND_ASSIGN(EnrollmentDomView);
 };
 
 }  // namespace
 
 EnterpriseEnrollmentView::EnterpriseEnrollmentView(
     EnterpriseEnrollmentController* controller)
-    : controller_(controller) {}
+    : controller_(controller),
+      editable_user_(true) {}
 
 EnterpriseEnrollmentView::~EnterpriseEnrollmentView() {}
 
 void EnterpriseEnrollmentView::Init() {
   // Use rounded rect background.
   views::Painter* painter =
       CreateWizardPainter(&BorderDefinition::kScreenBorder);
   set_background(views::Background::CreateBackgroundPainter(true, painter));
 
   // Create the view that hosts the enrollment page.
   enrollment_page_view_ = new EnrollmentDomView();
   enrollment_page_view_->set_border(
       views::Border::CreateEmptyBorder(kBorderSize, kBorderSize,
                                        kBorderSize, kBorderSize));
 
   AddChildView(enrollment_page_view_);
 
   // Load the enrollment page.
   Profile* profile = ProfileManager::GetDefaultProfile();
   GURL url(chrome::kChromeUIEnterpriseEnrollmentURL);
   enrollment_page_view_->Init(
       profile, SiteInstance::CreateSiteInstanceForURL(profile, url));
   EnterpriseEnrollmentUI::SetController(enrollment_page_view_->tab_contents(),
                                         this);
   enrollment_page_view_->LoadURL(url);
+
+  // Check lockbox data and update the view if needed.
+  chromeos::CryptohomeLibrary* cryptohome =
+      chromeos::CrosLibrary::Get()->GetCryptohomeLibrary();
+  // TODO(pastarmovj): This is being done either on the eula screen or on first
+  // login so maybe we should do it already here? If not remove.
+  if (cryptohome) {
+    if (cryptohome->TpmIsEnabled() && !cryptohome->TpmIsBeingOwned()) {
+      if (cryptohome->TpmIsOwned())
+        cryptohome->TpmClearStoredPassword();
+      else
+        cryptohome->TpmCanAttemptOwnership();
+    }
+
+    if (cryptohome->InstallAttributesIsReady() &&
+        !cryptohome->InstallAttributesIsFirstInstall()) {
+      std::string value;
+      if (cryptohome->InstallAttributesGet("enterprise.owned", &value) &&
+          0 == value.compare("true")) {
+        if (cryptohome->InstallAttributesGet("enterprise.user", &value)) {
+          DictionaryValue args;
+          args.SetString("user", value);
+          args.SetBoolean("editable_user", false);
+          editable_user_ = false;
+          UpdateGaiaLogin(args);

[Will Drewry, 2011/04/15 02:38:19]

Is this only used during enrollment or will enterprise.user be retrieved and
updated on each boot?

(I haven't quite pieced together that part, and being able to ensure we use the
right username for subsequent pulls is important, though fixable if we're not
that far along yet :)

+        } else {
+          // TODO(pastarmovj): Put some new error message here!
+          ShowError(IDS_ENTERPRISE_ENROLLMENT_FATAL_ENROLLMENT_ERROR);
+        }
+      }
+    }
+  } else {
+    // TODO(pastarmovj): Put some new error message here!
+    ShowError(IDS_ENTERPRISE_ENROLLMENT_FATAL_ENROLLMENT_ERROR);
+  }
 }
 
 void EnterpriseEnrollmentView::ShowConfirmationScreen() {
   RenderViewHost* render_view_host =
       enrollment_page_view_->tab_contents()->render_view_host();
   render_view_host->ExecuteJavascriptInWebFrame(
       string16(),
       UTF8ToUTF16("enterpriseEnrollment.showScreen('confirmation-screen');"));
 }
 
 void EnterpriseEnrollmentView::ShowAuthError(
     const GoogleServiceAuthError& error) {
   DictionaryValue args;
   args.SetInteger("error", error.state());
-  args.SetBoolean("editable_user", true);
+  args.SetBoolean("editable_user", editable_user_);
   args.SetString("captchaUrl", error.captcha().image_url.spec());
   UpdateGaiaLogin(args);
 }
 
 void EnterpriseEnrollmentView::ShowAccountError() {
   ShowError(IDS_ENTERPRISE_ENROLLMENT_ACCOUNT_ERROR);
 }
 
 void EnterpriseEnrollmentView::ShowFatalAuthError() {
   ShowError(IDS_ENTERPRISE_ENROLLMENT_FATAL_AUTH_ERROR);
 }
 
 void EnterpriseEnrollmentView::ShowFatalEnrollmentError() {
   ShowError(IDS_ENTERPRISE_ENROLLMENT_FATAL_ENROLLMENT_ERROR);
 }
 
 void EnterpriseEnrollmentView::ShowNetworkEnrollmentError() {
   ShowError(IDS_ENTERPRISE_ENROLLMENT_NETWORK_ENROLLMENT_ERROR);
 }
 
 void EnterpriseEnrollmentView::OnAuthSubmitted(const std::string& user,
                                                const std::string& password,
                                                const std::string& captcha,
                                                const std::string& access_code) {
+  user_ = user;
   controller_->Authenticate(user, password, captcha, access_code);
 }
 
 void EnterpriseEnrollmentView::OnAuthCancelled() {
   controller_->CancelEnrollment();
 }
 
 void EnterpriseEnrollmentView::OnConfirmationClosed() {
   controller_->CloseConfirmation();
 }
 
 void EnterpriseEnrollmentView::UpdateGaiaLogin(const DictionaryValue& args) {
   std::string json;
   base::JSONWriter::Write(&args, false, &json);
 
   RenderViewHost* render_view_host =
       enrollment_page_view_->tab_contents()->render_view_host();
   render_view_host->ExecuteJavascriptInWebFrame(
       ASCIIToUTF16("//iframe[@id='gaialogin']"),
       UTF8ToUTF16("showGaiaLogin(" + json + ");"));
 }
 
 void EnterpriseEnrollmentView::ShowError(int message_id) {
   DictionaryValue args;
   args.SetInteger("error", GoogleServiceAuthError::NONE);
-  args.SetBoolean("editable_user", true);
+  args.SetBoolean("editable_user", editable_user_);
   args.SetString("error_message", l10n_util::GetStringUTF16(message_id));
   UpdateGaiaLogin(args);
 }
 
 void EnterpriseEnrollmentView::Layout() {
   enrollment_page_view_->SetBoundsRect(GetContentsBounds());
 }
 
 }  // namespace chromeos