Revert 194578 "Add ash SessionStateDelegate"

trunk/src/ash/wm/session_state_controller_impl2_unittest.cc

 // 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.
 
 #include "ash/wm/session_state_controller_impl2.h"
 
 #include "ash/ash_switches.h"
-#include "ash/session_state_delegate.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/test_shell_delegate.h"
 #include "ash/wm/power_button_controller.h"
 #include "ash/wm/session_state_animator.h"
 #include "ash/wm/session_state_controller.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time.h"
@@ skipping 112 matching lines @@
     state_controller_ = static_cast<SessionStateControllerImpl2*>(
         Shell::GetInstance()->session_state_controller());
     state_controller_->SetDelegate(delegate_);  // transfers ownership
     test_api_.reset(
         new SessionStateControllerImpl2::TestApi(state_controller_));
     animator_api_.reset(
         new SessionStateAnimator::TestApi(state_controller_->
             animator_.get()));
     shell_delegate_ = reinterpret_cast<TestShellDelegate*>(
         ash::Shell::GetInstance()->delegate());
-    state_delegate_ = Shell::GetInstance()->session_state_delegate();
   }
 
   virtual void TearDown() {
     // TODO(antrim) : restore
     // animator_helper_->AdvanceUntilDone();
     AshTestBase::TearDown();
   }
 
  protected:
   void GenerateMouseMoveEvent() {
@@ skipping 153 matching lines @@
   void ExpectBackgroundIsHiding() {
     //TODO (antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating());
     EXPECT_TRUE(
         animator_api_->ContainersAreAnimated(
             SessionStateAnimator::DESKTOP_BACKGROUND,
             SessionStateAnimator::ANIMATION_FADE_OUT));
   }
 
   void ExpectUnlockedState() {
     //TODO (antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating());
-    EXPECT_FALSE(state_delegate_->IsScreenLocked());
+    EXPECT_FALSE(shell_delegate_->IsScreenLocked());
 
     aura::Window::Windows containers;
 
     SessionStateAnimator::GetContainers(
         SessionStateAnimator::LAUNCHER |
         SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
         &containers);
     for (aura::Window::Windows::const_iterator it = containers.begin();
          it != containers.end(); ++it) {
       aura::Window* window = *it;
       ui::Layer* layer = window->layer();
       EXPECT_EQ(1.0f, layer->opacity());
       EXPECT_EQ(0.0f, layer->layer_brightness());
       EXPECT_EQ(0.0f, layer->layer_saturation());
       EXPECT_EQ(gfx::Transform(), layer->transform());
     }
   }
 
   void ExpectLockedState() {
     //TODO (antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating());
-    EXPECT_TRUE(state_delegate_->IsScreenLocked());
+    EXPECT_TRUE(shell_delegate_->IsScreenLocked());
 
     aura::Window::Windows containers;
 
     SessionStateAnimator::GetContainers(
         SessionStateAnimator::LOCK_SCREEN_RELATED_CONTAINERS |
         SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
         &containers);
     for (aura::Window::Windows::const_iterator it = containers.begin();
          it != containers.end(); ++it) {
       aura::Window* window = *it;
@@ skipping 18 matching lines @@
   void PressLockButton() {
     controller_->OnLockButtonEvent(true, base::TimeTicks::Now());
   }
 
   void ReleaseLockButton() {
     controller_->OnLockButtonEvent(false, base::TimeTicks::Now());
   }
 
   void SystemLocks() {
     state_controller_->OnLockStateChanged(true);
-    state_delegate_->LockScreen();
+    shell_delegate_->LockScreen();
     //TODO (antrim) : restore animator_helper_->Advance(base::TimeDelta());
   }
 
   void SuccessfulAuthentication(bool* call_flag) {
     base::Closure closure = base::Bind(&CheckCalledCallback, call_flag);
     state_controller_->OnLockScreenHide(closure);
     //TODO (antrim) : restore animator_helper_->Advance(base::TimeDelta());
   }
 
   void SystemUnlocks() {
     state_controller_->OnLockStateChanged(false);
-    state_delegate_->UnlockScreen();
+    shell_delegate_->UnlockScreen();
     //TODO (antrim) : restore animator_helper_->Advance(base::TimeDelta());
   }
 
   void Initialize(bool legacy_button, user::LoginStatus status) {
     controller_->set_has_legacy_power_button_for_test(legacy_button);
     state_controller_->OnLoginStateChanged(status);
     SetUserLoggedIn(status != user::LOGGED_IN_NONE);
     if (status == user::LOGGED_IN_GUEST)
       SetCanLockScreen(false);
     state_controller_->OnLockStateChanged(false);
   }
 
   PowerButtonController* controller_;  // not owned
   SessionStateControllerImpl2* state_controller_;  // not owned
   TestSessionStateControllerDelegate* delegate_;  // not owned
   TestShellDelegate* shell_delegate_;  // not owned
-  SessionStateDelegate* state_delegate_;  // not owned
 
   scoped_ptr<ui::ScopedAnimationDurationScaleMode> animation_duration_mode_;
   scoped_ptr<SessionStateControllerImpl2::TestApi> test_api_;
   scoped_ptr<SessionStateAnimator::TestApi> animator_api_;
   // TODO(antrim) : restore
 //  scoped_ptr<ui::test::AnimationContainerTestHelper> animator_helper_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SessionStateControllerImpl2Test);
 };
@@ skipping 648 matching lines @@
 
   Advance(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
   ExpectUnlockAfterUIDestroyedAnimationFinished();
   EXPECT_TRUE(IsBackgroundHidden());
 
   ExpectUnlockedState();
 }
 
 }  // namespace test
 }  // namespace ash