diff --git a/ash/BUILD.gn b/ash/BUILD.gn
index fa3d1716..678b376e 100644
--- a/ash/BUILD.gn
+++ b/ash/BUILD.gn
@@ -216,6 +216,7 @@
     "laser/laser_pointer_view.h",
     "laser/laser_segment_utils.cc",
     "laser/laser_segment_utils.h",
+    "login/lock_screen_apps_focus_observer.h",
     "login/lock_screen_controller.cc",
     "login/lock_screen_controller.h",
     "login/ui/layout_util.cc",
diff --git a/ash/login/lock_screen_apps_focus_observer.h b/ash/login/lock_screen_apps_focus_observer.h
new file mode 100644
index 0000000..0383385
--- /dev/null
+++ b/ash/login/lock_screen_apps_focus_observer.h
@@ -0,0 +1,25 @@
+// Copyright 2017 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 ASH_LOGIN_LOCK_SCREEN_APPS_FOCUS_OBSERVER_H_
+#define ASH_LOGIN_LOCK_SCREEN_APPS_FOCUS_OBSERVER_H_
+
+#include "ash/ash_export.h"
+
+namespace ash {
+
+// An interface used to observe lock screen apps focus related events, as
+// reported through lock screen mojo interface.
+class ASH_EXPORT LockScreenAppsFocusObserver {
+ public:
+  virtual ~LockScreenAppsFocusObserver() {}
+
+  // Called when focus is leaving a lock screen app window due to tabbing.
+  // |reverse| - whether the tab order is reversed.
+  virtual void OnFocusLeavingLockScreenApps(bool reverse) = 0;
+};
+
+}  // namespace ash
+
+#endif  // ASH_LOGIN_LOCK_SCREEN_APPS_FOCUS_OBSERVER_H_
diff --git a/ash/login/lock_screen_controller.cc b/ash/login/lock_screen_controller.cc
index 4e25b6f..5e9de90f 100644
--- a/ash/login/lock_screen_controller.cc
+++ b/ash/login/lock_screen_controller.cc
@@ -4,6 +4,7 @@
 
 #include "ash/login/lock_screen_controller.h"
 
+#include "ash/login/lock_screen_apps_focus_observer.h"
 #include "ash/login/ui/lock_screen.h"
 #include "ash/login/ui/login_data_dispatcher.h"
 #include "ash/public/cpp/ash_pref_names.h"
@@ -122,6 +123,11 @@
       &LockScreenController::OnGetSystemSalt, base::Unretained(this)));
 }
 
+void LockScreenController::HandleFocusLeavingLockScreenApps(bool reverse) {
+  for (auto& observer : lock_screen_apps_focus_observers_)
+    observer.OnFocusLeavingLockScreenApps(reverse);
+}
+
 void LockScreenController::AttemptUnlock(const AccountId& account_id) {
   if (!lock_screen_client_)
     return;
@@ -177,6 +183,26 @@
   lock_screen_client_->OnMaxIncorrectPasswordAttempted(account_id);
 }
 
+void LockScreenController::FocusLockScreenApps(bool reverse) {
+  if (!lock_screen_client_)
+    return;
+  lock_screen_client_->FocusLockScreenApps(reverse);
+}
+
+void LockScreenController::AddLockScreenAppsFocusObserver(
+    LockScreenAppsFocusObserver* observer) {
+  lock_screen_apps_focus_observers_.AddObserver(observer);
+}
+
+void LockScreenController::RemoveLockScreenAppsFocusObserver(
+    LockScreenAppsFocusObserver* observer) {
+  lock_screen_apps_focus_observers_.RemoveObserver(observer);
+}
+
+void LockScreenController::FlushForTesting() {
+  lock_screen_client_.FlushForTesting();
+}
+
 void LockScreenController::DoAuthenticateUser(
     const AccountId& account_id,
     const std::string& password,
diff --git a/ash/login/lock_screen_controller.h b/ash/login/lock_screen_controller.h
index 4cb9567..befb5fd3 100644
--- a/ash/login/lock_screen_controller.h
+++ b/ash/login/lock_screen_controller.h
@@ -8,12 +8,14 @@
 #include "ash/ash_export.h"
 #include "ash/public/interfaces/lock_screen.mojom.h"
 #include "base/macros.h"
+#include "base/observer_list.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 
 class PrefRegistrySimple;
 
 namespace ash {
 
+class LockScreenAppsFocusObserver;
 class LoginDataDispatcher;
 
 // LockScreenController implements mojom::LockScreen and wraps the
@@ -51,6 +53,7 @@
                  bool show_guest) override;
   void SetPinEnabledForUser(const AccountId& account_id,
                             bool is_enabled) override;
+  void HandleFocusLeavingLockScreenApps(bool reverse) override;
 
   // Wrappers around the mojom::LockScreenClient interface.
   // Hash the password and send AuthenticateUser request to LockScreenClient.
@@ -71,6 +74,16 @@
   void SignOutUser();
   void CancelAddUser();
   void OnMaxIncorrectPasswordAttempted(const AccountId& account_id);
+  void FocusLockScreenApps(bool reverse);
+
+  // Methods to manage lock screen apps focus observers.
+  // The observers will be notified when lock screen apps focus changes are
+  // reported via lock screen mojo interface.
+  void AddLockScreenAppsFocusObserver(LockScreenAppsFocusObserver* observer);
+  void RemoveLockScreenAppsFocusObserver(LockScreenAppsFocusObserver* observer);
+
+  // Flushes the mojo pipes - to be used in tests.
+  void FlushForTesting();
 
  private:
   using PendingAuthenticateUserCall =
@@ -97,6 +110,9 @@
   // User authentication call that will run when we have system salt.
   PendingAuthenticateUserCall pending_user_auth_;
 
+  base::ObserverList<LockScreenAppsFocusObserver>
+      lock_screen_apps_focus_observers_;
+
   DISALLOW_COPY_AND_ASSIGN(LockScreenController);
 };
 
diff --git a/ash/login/mock_lock_screen_client.h b/ash/login/mock_lock_screen_client.h
index a0867ed..85fec52a 100644
--- a/ash/login/mock_lock_screen_client.h
+++ b/ash/login/mock_lock_screen_client.h
@@ -44,6 +44,7 @@
   MOCK_METHOD0(CancelAddUser, void());
   MOCK_METHOD1(OnMaxIncorrectPasswordAttempted,
                void(const AccountId& account_id));
+  MOCK_METHOD1(FocusLockScreenApps, void(bool reverse));
 
  private:
   bool authenticate_user_callback_result_ = true;
diff --git a/ash/login/ui/lock_contents_view.cc b/ash/login/ui/lock_contents_view.cc
index 4e16703..2210885 100644
--- a/ash/login/ui/lock_contents_view.cc
+++ b/ash/login/ui/lock_contents_view.cc
@@ -170,6 +170,7 @@
       display_observer_(this) {
   data_dispatcher_->AddObserver(this);
   display_observer_.Add(display::Screen::GetScreen());
+  Shell::Get()->lock_screen_controller()->AddLockScreenAppsFocusObserver(this);
   Shell::Get()->system_tray_notifier()->AddSystemTrayFocusObserver(this);
   error_bubble_ = base::MakeUnique<LoginBubble>();
 
@@ -186,10 +187,14 @@
   note_action_ =
       new NoteActionLaunchButton(initial_note_action_state, data_dispatcher_);
   AddChildView(note_action_);
+
+  OnLockScreenNoteStateChanged(initial_note_action_state);
 }
 
 LockContentsView::~LockContentsView() {
   data_dispatcher_->RemoveObserver(this);
+  Shell::Get()->lock_screen_controller()->RemoveLockScreenAppsFocusObserver(
+      this);
   Shell::Get()->system_tray_notifier()->RemoveSystemTrayFocusObserver(this);
 }
 
@@ -228,7 +233,12 @@
 void LockContentsView::AboutToRequestFocusFromTabTraversal(bool reverse) {
   // The LockContentsView itself doesn't have anything to focus. If it gets
   // focused we should change the currently focused widget (ie, to the shelf or
-  // status area).
+  // status area, or lock screen apps, if they are active).
+  if (reverse && lock_screen_apps_active_) {
+    Shell::Get()->lock_screen_controller()->FocusLockScreenApps(reverse);
+    return;
+  }
+
   FocusNextWidget(reverse);
 }
 
@@ -305,10 +315,38 @@
   }
 }
 
+void LockContentsView::OnLockScreenNoteStateChanged(
+    mojom::TrayActionState state) {
+  bool old_lock_screen_apps_active = lock_screen_apps_active_;
+  lock_screen_apps_active_ = state == mojom::TrayActionState::kActive;
+
+  // If lock screen apps just got deactivated - request focus for primary auth,
+  // which should focus the password field.
+  if (old_lock_screen_apps_active && !lock_screen_apps_active_ && primary_auth_)
+    primary_auth_->RequestFocus();
+}
+
+void LockContentsView::OnFocusLeavingLockScreenApps(bool reverse) {
+  if (!reverse || lock_screen_apps_active_)
+    FocusNextWidget(reverse);
+  else
+    FindFirstOrLastFocusableChild(this, reverse)->RequestFocus();
+}
+
 void LockContentsView::OnFocusLeavingSystemTray(bool reverse) {
   // This function is called when the system tray is losing focus. We want to
-  // focus the first or last child in this view.
+  // focus the first or last child in this view, or a lock screen app window if
+  // one is active (in which case lock contents should not have focus). In the
+  // later case, still focus lock screen first, to synchronously take focus away
+  // from the system shelf (or tray) - lock shelf view expect the focus to be
+  // taken when it passes it to lock screen view, and can misbehave in case the
+  // focus is kept in it.
   FindFirstOrLastFocusableChild(this, reverse)->RequestFocus();
+
+  if (lock_screen_apps_active_) {
+    Shell::Get()->lock_screen_controller()->FocusLockScreenApps(reverse);
+    return;
+  }
 }
 
 void LockContentsView::OnDisplayMetricsChanged(const display::Display& display,
diff --git a/ash/login/ui/lock_contents_view.h b/ash/login/ui/lock_contents_view.h
index 30203e0..f7f4a299 100644
--- a/ash/login/ui/lock_contents_view.h
+++ b/ash/login/ui/lock_contents_view.h
@@ -10,6 +10,7 @@
 #include <vector>
 
 #include "ash/ash_export.h"
+#include "ash/login/lock_screen_apps_focus_observer.h"
 #include "ash/login/ui/login_data_dispatcher.h"
 #include "ash/login/ui/non_accessible_view.h"
 #include "ash/system/system_tray_focus_observer.h"
@@ -41,6 +42,7 @@
 // but it is always shown on the primary display. There is only one instance
 // at a time.
 class ASH_EXPORT LockContentsView : public NonAccessibleView,
+                                    public LockScreenAppsFocusObserver,
                                     public LoginDataDispatcher::Observer,
                                     public SystemTrayFocusObserver,
                                     public display::DisplayObserver {
@@ -70,10 +72,14 @@
   void OnFocus() override;
   void AboutToRequestFocusFromTabTraversal(bool reverse) override;
 
+  // LockScreenAppsFocusObserver:
+  void OnFocusLeavingLockScreenApps(bool reverse) override;
+
   // LoginDataDispatcher::Observer:
   void OnUsersChanged(
       const std::vector<mojom::LoginUserInfoPtr>& users) override;
   void OnPinEnabledForUserChanged(const AccountId& user, bool enabled) override;
+  void OnLockScreenNoteStateChanged(mojom::TrayActionState state) override;
 
   // SystemTrayFocusObserver:
   void OnFocusLeavingSystemTray(bool reverse) override;
@@ -178,6 +184,10 @@
   std::unique_ptr<LoginBubble> error_bubble_;
   int unlock_attempt_ = 0;
 
+  // Whether a lock screen app is currently active (i.e. lock screen note action
+  // state is reported as kActive by the data dispatcher).
+  bool lock_screen_apps_active_ = false;
+
   DISALLOW_COPY_AND_ASSIGN(LockContentsView);
 };
 
diff --git a/ash/login/ui/lock_contents_view_unittest.cc b/ash/login/ui/lock_contents_view_unittest.cc
index 4401df1..7db9047 100644
--- a/ash/login/ui/lock_contents_view_unittest.cc
+++ b/ash/login/ui/lock_contents_view_unittest.cc
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <memory>
 #include <unordered_set>
 
 #include "ash/login/ui/lock_contents_view.h"
@@ -28,7 +29,7 @@
   auto* contents = new LockContentsView(mojom::TrayActionState::kNotAvailable,
                                         data_dispatcher());
   SetUserCount(1);
-  ShowWidgetWithContent(contents);
+  std::unique_ptr<views::Widget> widget = CreateWidgetWithContent(contents);
 
   // Verify user list and secondary auth are not shown for one user.
   LockContentsView::TestApi test_api(contents);
@@ -72,11 +73,11 @@
   auto* contents = new LockContentsView(mojom::TrayActionState::kNotAvailable,
                                         data_dispatcher());
   SetUserCount(1);
-  ShowWidgetWithContent(contents);
+  std::unique_ptr<views::Widget> widget = CreateWidgetWithContent(contents);
 
   LockContentsView::TestApi test_api(contents);
   LoginAuthUserView* auth_view = test_api.primary_auth();
-  gfx::Rect widget_bounds = widget()->GetWindowBoundsInScreen();
+  gfx::Rect widget_bounds = widget->GetWindowBoundsInScreen();
   int expected_margin =
       (widget_bounds.width() - auth_view->GetPreferredSize().width()) / 2;
   gfx::Rect auth_bounds = auth_view->GetBoundsInScreen();
@@ -93,11 +94,11 @@
   auto* contents = new LockContentsView(mojom::TrayActionState::kAvailable,
                                         data_dispatcher());
   SetUserCount(1);
-  ShowWidgetWithContent(contents);
+  std::unique_ptr<views::Widget> widget = CreateWidgetWithContent(contents);
 
   LockContentsView::TestApi test_api(contents);
   LoginAuthUserView* auth_view = test_api.primary_auth();
-  gfx::Rect widget_bounds = widget()->GetWindowBoundsInScreen();
+  gfx::Rect widget_bounds = widget->GetWindowBoundsInScreen();
   int expected_margin =
       (widget_bounds.width() - auth_view->GetPreferredSize().width()) / 2;
   gfx::Rect auth_bounds = auth_view->GetBoundsInScreen();
@@ -117,7 +118,7 @@
                                         data_dispatcher());
   LockContentsView::TestApi test_api(contents);
   SetUserCount(3);
-  ShowWidgetWithContent(contents);
+  std::unique_ptr<views::Widget> widget = CreateWidgetWithContent(contents);
 
   // Returns the distance between the auth user view and the user view.
   auto calculate_distance = [&]() {
@@ -131,7 +132,7 @@
 
   const display::Display& display =
       display::Screen::GetScreen()->GetDisplayNearestWindow(
-          widget()->GetNativeWindow());
+          widget->GetNativeWindow());
   for (int i = 2; i < 10; ++i) {
     SetUserCount(i);
 
@@ -166,7 +167,7 @@
                                         data_dispatcher());
   LockContentsView::TestApi test_api(contents);
   SetUserCount(2);
-  ShowWidgetWithContent(contents);
+  std::unique_ptr<views::Widget> widget = CreateWidgetWithContent(contents);
 
   // Capture user info to validate it did not change during the swap.
   AccountId primary_user =
@@ -212,7 +213,7 @@
   LockContentsView::TestApi test_api(contents);
   SetUserCount(5);
   EXPECT_EQ(users().size() - 1, test_api.user_views().size());
-  ShowWidgetWithContent(contents);
+  std::unique_ptr<views::Widget> widget = CreateWidgetWithContent(contents);
 
   LoginAuthUserView* auth_view = test_api.primary_auth();
 
@@ -249,7 +250,7 @@
   auto* contents = new LockContentsView(mojom::TrayActionState::kNotAvailable,
                                         data_dispatcher());
   SetUserCount(1);
-  ShowWidgetWithContent(contents);
+  std::unique_ptr<views::Widget> widget = CreateWidgetWithContent(contents);
 
   LockContentsView::TestApi test_api(contents);
 
@@ -263,7 +264,7 @@
   EXPECT_TRUE(test_api.note_action()->visible());
 
   // Verify the bounds of the note action button are as expected.
-  gfx::Rect widget_bounds = widget()->GetWindowBoundsInScreen();
+  gfx::Rect widget_bounds = widget->GetWindowBoundsInScreen();
   gfx::Size note_action_size = test_api.note_action()->GetPreferredSize();
   EXPECT_EQ(gfx::Rect(widget_bounds.top_right() -
                           gfx::Vector2d(note_action_size.width(), 0),
@@ -283,14 +284,14 @@
   auto* contents = new LockContentsView(mojom::TrayActionState::kAvailable,
                                         data_dispatcher());
   SetUserCount(1);
-  ShowWidgetWithContent(contents);
+  std::unique_ptr<views::Widget> widget = CreateWidgetWithContent(contents);
 
   LockContentsView::TestApi test_api(contents);
 
   // Verify the note action button is visible and positioned in the top rigth
   // corner of the screen.
   EXPECT_TRUE(test_api.note_action()->visible());
-  gfx::Rect widget_bounds = widget()->GetWindowBoundsInScreen();
+  gfx::Rect widget_bounds = widget->GetWindowBoundsInScreen();
   gfx::Size note_action_size = test_api.note_action()->GetPreferredSize();
   EXPECT_EQ(gfx::Rect(widget_bounds.top_right() -
                           gfx::Vector2d(note_action_size.width(), 0),
diff --git a/ash/login/ui/lock_screen_sanity_unittest.cc b/ash/login/ui/lock_screen_sanity_unittest.cc
index c50030cd..e14cdf3 100644
--- a/ash/login/ui/lock_screen_sanity_unittest.cc
+++ b/ash/login/ui/lock_screen_sanity_unittest.cc
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <memory>
+
+#include "ash/login/lock_screen_controller.h"
 #include "ash/login/mock_lock_screen_client.h"
 #include "ash/login/ui/lock_contents_view.h"
 #include "ash/login/ui/login_test_base.h"
@@ -16,13 +19,35 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/views/focus/focus_manager.h"
+#include "ui/views/widget/widget.h"
 
 using ::testing::_;
+using ::testing::Invoke;
 using LockScreenSanityTest = ash::LoginTestBase;
 
 namespace ash {
 namespace {
 
+class LockScreenAppFocuser {
+ public:
+  explicit LockScreenAppFocuser(views::Widget* lock_screen_app_widget)
+      : lock_screen_app_widget_(lock_screen_app_widget) {}
+  ~LockScreenAppFocuser() = default;
+
+  bool reversed_tab_order() const { return reversed_tab_order_; }
+
+  void FocusLockScreenApp(bool reverse) {
+    reversed_tab_order_ = reverse;
+    lock_screen_app_widget_->Activate();
+  }
+
+ private:
+  bool reversed_tab_order_ = false;
+  views::Widget* lock_screen_app_widget_;
+
+  DISALLOW_COPY_AND_ASSIGN(LockScreenAppFocuser);
+};
+
 // Returns true if |view| or any child of it has focus.
 bool HasFocusInAnyChildView(views::View* view) {
   if (view->HasFocus())
@@ -34,14 +59,41 @@
   return false;
 }
 
-void ExpectFocused(views::View* view) {
-  EXPECT_TRUE(view->GetWidget()->IsActive());
-  EXPECT_TRUE(HasFocusInAnyChildView(view));
+// Keeps tabbing through |view| until the view loses focus.
+// The number of generated tab events will be limited - if the focus is still
+// within the view by the time the limit is hit, this will return false.
+bool TabThroughView(ui::test::EventGenerator* event_generator,
+                    views::View* view,
+                    bool reverse) {
+  if (!HasFocusInAnyChildView(view)) {
+    ADD_FAILURE() << "View not focused initially.";
+    return false;
+  }
+
+  for (int i = 0; i < 50; ++i) {
+    event_generator->PressKey(ui::KeyboardCode::VKEY_TAB,
+                              reverse ? ui::EF_SHIFT_DOWN : 0);
+    if (!HasFocusInAnyChildView(view))
+      return true;
+  }
+
+  return false;
 }
 
-void ExpectNotFocused(views::View* view) {
-  EXPECT_FALSE(view->GetWidget()->IsActive());
-  EXPECT_FALSE(HasFocusInAnyChildView(view));
+testing::AssertionResult VerifyFocused(views::View* view) {
+  if (!view->GetWidget()->IsActive())
+    return testing::AssertionFailure() << "Widget not active.";
+  if (!HasFocusInAnyChildView(view))
+    return testing::AssertionFailure() << "No focused descendant.";
+  return testing::AssertionSuccess();
+}
+
+testing::AssertionResult VerifyNotFocused(views::View* view) {
+  if (view->GetWidget()->IsActive())
+    return testing::AssertionFailure() << "Widget active";
+  if (HasFocusInAnyChildView(view))
+    return testing::AssertionFailure() << "Has focused descendant.";
+  return testing::AssertionSuccess();
 }
 
 }  // namespace
@@ -55,7 +107,7 @@
   // The lock screen requires at least one user.
   SetUserCount(1);
 
-  ShowWidgetWithContent(contents);
+  std::unique_ptr<views::Widget> widget = CreateWidgetWithContent(contents);
 
   // Textfield should have focus.
   EXPECT_EQ(MakeLoginPasswordTestApi(contents).textfield(),
@@ -75,7 +127,7 @@
   // The lock screen requires at least one user.
   SetUserCount(1);
 
-  ShowWidgetWithContent(contents);
+  std::unique_ptr<views::Widget> widget = CreateWidgetWithContent(contents);
 
   // Password submit runs mojo.
   std::unique_ptr<MockLockScreenClient> client = BindMockLockScreenClient();
@@ -100,28 +152,24 @@
   auto* lock = new LockContentsView(mojom::TrayActionState::kNotAvailable,
                                     data_dispatcher());
   SetUserCount(1);
-  ShowWidgetWithContent(lock);
+  std::unique_ptr<views::Widget> widget = CreateWidgetWithContent(lock);
   views::View* shelf = Shelf::ForWindow(lock->GetWidget()->GetNativeWindow())
                            ->shelf_widget()
                            ->GetContentsView();
 
   // Lock has focus.
-  ExpectFocused(lock);
-  ExpectNotFocused(shelf);
+  EXPECT_TRUE(VerifyFocused(lock));
+  EXPECT_TRUE(VerifyNotFocused(shelf));
 
   // Tab (eventually) goes to the shelf.
-  for (int i = 0; i < 50; ++i) {
-    GetEventGenerator().PressKey(ui::KeyboardCode::VKEY_TAB, 0);
-    if (!HasFocusInAnyChildView(lock))
-      break;
-  }
-  ExpectNotFocused(lock);
-  ExpectFocused(shelf);
+  ASSERT_TRUE(TabThroughView(&GetEventGenerator(), lock, false /*reverse*/));
+  EXPECT_TRUE(VerifyNotFocused(lock));
+  EXPECT_TRUE(VerifyFocused(shelf));
 
   // A single shift+tab brings focus back to the lock screen.
   GetEventGenerator().PressKey(ui::KeyboardCode::VKEY_TAB, ui::EF_SHIFT_DOWN);
-  ExpectFocused(lock);
-  ExpectNotFocused(shelf);
+  EXPECT_TRUE(VerifyFocused(lock));
+  EXPECT_TRUE(VerifyNotFocused(shelf));
 }
 
 // Verifies that shift-tabbing from the lock screen will eventually focus the
@@ -135,7 +183,7 @@
   auto* lock = new LockContentsView(mojom::TrayActionState::kNotAvailable,
                                     data_dispatcher());
   SetUserCount(1);
-  ShowWidgetWithContent(lock);
+  std::unique_ptr<views::Widget> widget = CreateWidgetWithContent(lock);
   views::View* status_area =
       RootWindowController::ForWindow(lock->GetWidget()->GetNativeWindow())
           ->GetSystemTray()
@@ -143,8 +191,8 @@
           ->GetContentsView();
 
   // Lock screen has focus.
-  ExpectFocused(lock);
-  ExpectNotFocused(status_area);
+  EXPECT_TRUE(VerifyFocused(lock));
+  EXPECT_TRUE(VerifyNotFocused(status_area));
 
   // Two shift+tab bring focus to the status area.
   // TODO(crbug.com/768076): Only one shift+tab is needed as the focus should
@@ -156,13 +204,122 @@
   // Focus from user view to the status area.
   GetEventGenerator().PressKey(ui::KeyboardCode::VKEY_TAB, ui::EF_SHIFT_DOWN);
 
-  ExpectNotFocused(lock);
-  ExpectFocused(status_area);
+  EXPECT_TRUE(VerifyNotFocused(lock));
+  EXPECT_TRUE(VerifyFocused(status_area));
 
   // A single tab brings focus back to the lock screen.
   GetEventGenerator().PressKey(ui::KeyboardCode::VKEY_TAB, 0);
-  ExpectFocused(lock);
-  ExpectNotFocused(status_area);
+  EXPECT_TRUE(VerifyFocused(lock));
+  EXPECT_TRUE(VerifyNotFocused(status_area));
+}
+
+TEST_F(LockScreenSanityTest, TabWithLockScreenAppActive) {
+  GetSessionControllerClient()->SetSessionState(
+      session_manager::SessionState::LOCKED);
+
+  auto* lock = new LockContentsView(mojom::TrayActionState::kNotAvailable,
+                                    data_dispatcher());
+  SetUserCount(1);
+  std::unique_ptr<views::Widget> widget = CreateWidgetWithContent(lock);
+
+  views::View* shelf = Shelf::ForWindow(lock->GetWidget()->GetNativeWindow())
+                           ->shelf_widget()
+                           ->GetContentsView();
+
+  views::View* status_area =
+      RootWindowController::ForWindow(lock->GetWidget()->GetNativeWindow())
+          ->GetSystemTray()
+          ->GetWidget()
+          ->GetContentsView();
+
+  LockScreenController* lock_screen_controller =
+      Shell::Get()->lock_screen_controller();
+
+  // Initialize lock screen action state.
+  data_dispatcher()->SetLockScreenNoteState(mojom::TrayActionState::kActive);
+
+  // Create and focus a lock screen app window.
+  auto* lock_screen_app = new views::View();
+  lock_screen_app->SetFocusBehavior(views::View::FocusBehavior::ALWAYS);
+  std::unique_ptr<views::Widget> app_widget =
+      CreateWidgetWithContent(lock_screen_app);
+  app_widget->Show();
+
+  // Lock screen app focus is requested using lock screen mojo client - set up
+  // the mock client.
+  LockScreenAppFocuser app_widget_focuser(app_widget.get());
+  std::unique_ptr<MockLockScreenClient> client = BindMockLockScreenClient();
+  EXPECT_CALL(*client, FocusLockScreenApps(_))
+      .WillRepeatedly(Invoke(&app_widget_focuser,
+                             &LockScreenAppFocuser::FocusLockScreenApp));
+
+  // Initially, focus should be with the lock screen app - when the app loses
+  // focus (notified via mojo interface), shelf should get the focus next.
+  EXPECT_TRUE(VerifyFocused(lock_screen_app));
+  lock_screen_controller->HandleFocusLeavingLockScreenApps(false /*reverse*/);
+  EXPECT_TRUE(VerifyFocused(shelf));
+
+  // Reversing focus should bring focus back to the lock screen app.
+  GetEventGenerator().PressKey(ui::KeyboardCode::VKEY_TAB, ui::EF_SHIFT_DOWN);
+  // Focus is passed to lock screen apps via mojo - flush the request.
+  lock_screen_controller->FlushForTesting();
+  EXPECT_TRUE(VerifyFocused(lock_screen_app));
+  EXPECT_TRUE(app_widget_focuser.reversed_tab_order());
+
+  // Have the app tab out in reverse tab order - in this case, the status area
+  // should get the focus.
+  lock_screen_controller->HandleFocusLeavingLockScreenApps(true /*reverse*/);
+  EXPECT_TRUE(VerifyFocused(status_area));
+
+  // Tabbing out of the status area (in default order) should focus the lock
+  // screen app again.
+  GetEventGenerator().PressKey(ui::KeyboardCode::VKEY_TAB, 0);
+  // Focus is passed to lock screen apps via mojo - flush the request.
+  lock_screen_controller->FlushForTesting();
+  EXPECT_TRUE(VerifyFocused(lock_screen_app));
+  EXPECT_FALSE(app_widget_focuser.reversed_tab_order());
+
+  // Tab out of the lock screen app once more - the shelf should get the focus
+  // again.
+  lock_screen_controller->HandleFocusLeavingLockScreenApps(false /*reverse*/);
+  EXPECT_TRUE(VerifyFocused(shelf));
+}
+
+TEST_F(LockScreenSanityTest, FocusLockScreenWhenLockScreenAppExit) {
+  // Set up lock screen.
+  GetSessionControllerClient()->SetSessionState(
+      session_manager::SessionState::LOCKED);
+  auto* lock = new LockContentsView(mojom::TrayActionState::kNotAvailable,
+                                    data_dispatcher());
+  SetUserCount(1);
+  std::unique_ptr<views::Widget> widget = CreateWidgetWithContent(lock);
+
+  views::View* shelf = Shelf::ForWindow(lock->GetWidget()->GetNativeWindow())
+                           ->shelf_widget()
+                           ->GetContentsView();
+
+  // Setup and focus a lock screen app.
+  data_dispatcher()->SetLockScreenNoteState(mojom::TrayActionState::kActive);
+  auto* lock_screen_app = new views::View();
+  lock_screen_app->SetFocusBehavior(views::View::FocusBehavior::ALWAYS);
+  std::unique_ptr<views::Widget> app_widget =
+      CreateWidgetWithContent(lock_screen_app);
+  app_widget->Show();
+  EXPECT_TRUE(VerifyFocused(lock_screen_app));
+
+  // Tab out of the lock screen app - shelf should get the focus.
+  Shell::Get()->lock_screen_controller()->HandleFocusLeavingLockScreenApps(
+      false /*reverse*/);
+  EXPECT_TRUE(VerifyFocused(shelf));
+
+  // Move the lock screen note taking to available state (which happens when the
+  // app session ends) - this should focus the lock screen.
+  data_dispatcher()->SetLockScreenNoteState(mojom::TrayActionState::kAvailable);
+  EXPECT_TRUE(VerifyFocused(lock));
+
+  // Tab through the lock screen - the focus should eventually get to the shelf.
+  ASSERT_TRUE(TabThroughView(&GetEventGenerator(), lock, false /*reverse*/));
+  EXPECT_TRUE(VerifyFocused(shelf));
 }
 
 }  // namespace ash
diff --git a/ash/login/ui/login_auth_user_view_unittest.cc b/ash/login/ui/login_auth_user_view_unittest.cc
index e5c31fa5..ed31636 100644
--- a/ash/login/ui/login_auth_user_view_unittest.cc
+++ b/ash/login/ui/login_auth_user_view_unittest.cc
@@ -6,6 +6,7 @@
 #include "ash/login/ui/login_test_base.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/views/layout/box_layout.h"
+#include "ui/views/widget/widget.h"
 
 namespace ash {
 
@@ -30,7 +31,7 @@
     container_->SetLayoutManager(
         new views::BoxLayout(views::BoxLayout::kVertical));
     container_->AddChildView(view_);
-    ShowWidgetWithContent(container_);
+    SetWidget(CreateWidgetWithContent(container_));
   }
 
   mojom::LoginUserInfoPtr user_;
@@ -76,4 +77,4 @@
   EXPECT_TRUE(user_test.is_opaque());
 }
 
-}  // namespace ash
\ No newline at end of file
+}  // namespace ash
diff --git a/ash/login/ui/login_bubble_unittest.cc b/ash/login/ui/login_bubble_unittest.cc
index 1de9292..88c878f 100644
--- a/ash/login/ui/login_bubble_unittest.cc
+++ b/ash/login/ui/login_bubble_unittest.cc
@@ -7,6 +7,7 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/views/layout/box_layout.h"
+#include "ui/views/widget/widget.h"
 
 namespace ash {
 
@@ -51,7 +52,7 @@
 
     container_->AddChildView(bubble_opener_);
     container_->AddChildView(other_view_);
-    ShowWidgetWithContent(container_);
+    SetWidget(CreateWidgetWithContent(container_));
 
     bubble_ = base::MakeUnique<LoginBubble>();
   }
diff --git a/ash/login/ui/login_password_view_test.cc b/ash/login/ui/login_password_view_test.cc
index 90b77422..fe09c18 100644
--- a/ash/login/ui/login_password_view_test.cc
+++ b/ash/login/ui/login_password_view_test.cc
@@ -9,6 +9,7 @@
 #include "ash/shell.h"
 #include "base/strings/utf_string_conversions.h"
 #include "ui/events/test/event_generator.h"
+#include "ui/views/widget/widget.h"
 
 namespace ash {
 
@@ -28,7 +29,7 @@
                            base::Unretained(this)),
                 base::Bind(&LoginPasswordViewTest::OnPasswordTextChanged,
                            base::Unretained(this)));
-    ShowWidgetWithContent(view_);
+    SetWidget(CreateWidgetWithContent(view_));
   }
 
   // Called when a password is submitted.
diff --git a/ash/login/ui/login_pin_view_unittest.cc b/ash/login/ui/login_pin_view_unittest.cc
index 7327f607..0f6201b 100644
--- a/ash/login/ui/login_pin_view_unittest.cc
+++ b/ash/login/ui/login_pin_view_unittest.cc
@@ -8,6 +8,7 @@
 #include "ash/login/ui/login_test_base.h"
 #include "base/timer/mock_timer.h"
 #include "ui/events/test/event_generator.h"
+#include "ui/views/widget/widget.h"
 
 namespace ash {
 
@@ -26,7 +27,7 @@
         base::Bind(&LoginPinViewTest::OnPinKey, base::Unretained(this)),
         base::Bind(&LoginPinViewTest::OnPinBackspace, base::Unretained(this)));
 
-    ShowWidgetWithContent(view_);
+    SetWidget(CreateWidgetWithContent(view_));
   }
 
   // Called when a password is submitted.
@@ -156,4 +157,4 @@
   EXPECT_EQ(0, backspace_);
 }
 
-}  // namespace ash
\ No newline at end of file
+}  // namespace ash
diff --git a/ash/login/ui/login_test_base.cc b/ash/login/ui/login_test_base.cc
index 705e400..7413569 100644
--- a/ash/login/ui/login_test_base.cc
+++ b/ash/login/ui/login_test_base.cc
@@ -26,6 +26,7 @@
   ~WidgetDelegate() override = default;
 
   // views::WidgetDelegate:
+  void DeleteDelegate() override { delete this; }
   views::View* GetInitiallyFocusedView() override { return content_; }
   views::Widget* GetWidget() override { return content_->GetWidget(); }
   const views::Widget* GetWidget() const override {
@@ -42,16 +43,19 @@
 
 LoginTestBase::~LoginTestBase() = default;
 
-void LoginTestBase::ShowWidgetWithContent(views::View* content) {
-  EXPECT_FALSE(widget_) << "CreateWidget can only be called once.";
+void LoginTestBase::SetWidget(std::unique_ptr<views::Widget> widget) {
+  EXPECT_FALSE(widget_) << "SetWidget can only be called once.";
+  widget_ = std::move(widget);
+}
 
-  delegate_ = base::MakeUnique<WidgetDelegate>(content);
-
+std::unique_ptr<views::Widget> LoginTestBase::CreateWidgetWithContent(
+    views::View* content) {
   views::Widget::InitParams params(
       views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
+  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.context = CurrentContext();
   params.bounds = gfx::Rect(0, 0, 800, 800);
-  params.delegate = delegate_.get();
+  params.delegate = new WidgetDelegate(content);
 
   // Set the widget to the lock screen container, since a test may change the
   // session state to locked, which will hide all widgets not associated with
@@ -59,11 +63,11 @@
   params.parent = Shell::GetContainer(Shell::GetPrimaryRootWindow(),
                                       kShellWindowId_LockScreenContainer);
 
-  widget_ = new views::Widget();
-  widget_->Init(params);
-  widget_->SetContentsView(content);
-  widget_->Show();
-  ASSERT_TRUE(widget()->IsActive());
+  auto new_widget = std::make_unique<views::Widget>();
+  new_widget->Init(params);
+  new_widget->SetContentsView(content);
+  new_widget->Show();
+  return new_widget;
 }
 
 mojom::LoginUserInfoPtr LoginTestBase::CreateUser(
@@ -96,10 +100,7 @@
 }
 
 void LoginTestBase::TearDown() {
-  if (widget_) {
-    widget_->Close();
-    widget_ = nullptr;
-  }
+  widget_.reset();
 
   AshTestBase::TearDown();
 }
diff --git a/ash/login/ui/login_test_base.h b/ash/login/ui/login_test_base.h
index edb5c98..8d61521 100644
--- a/ash/login/ui/login_test_base.h
+++ b/ash/login/ui/login_test_base.h
@@ -5,6 +5,8 @@
 #ifndef ASH_LOGIN_UI_LOGIN_TEST_BASE_H_
 #define ASH_LOGIN_UI_LOGIN_TEST_BASE_H_
 
+#include <memory>
+
 #include "ash/login/ui/login_data_dispatcher.h"
 #include "ash/public/interfaces/login_user_info.mojom.h"
 #include "ash/test/ash_test_base.h"
@@ -24,10 +26,16 @@
   LoginTestBase();
   ~LoginTestBase() override;
 
-  // Creates and displays a widget containing |content|.
-  void ShowWidgetWithContent(views::View* content);
+  // Sets the primary test widget. The widget can be retrieved using |widget()|.
+  // This can be used to make a wdiget scoped to the whole test, e.g. if the
+  // widget is created in a SetUp override.
+  // May be called at most once.
+  void SetWidget(std::unique_ptr<views::Widget> widget);
+  views::Widget* widget() const { return widget_.get(); }
 
-  views::Widget* widget() const { return widget_; }
+  // Creates a widget containing |content|. The created widget will initially be
+  // shown.
+  std::unique_ptr<views::Widget> CreateWidgetWithContent(views::View* content);
 
   // Utility method to create a new |mojom::UserInfoPtr| instance.
   mojom::LoginUserInfoPtr CreateUser(const std::string& name) const;
@@ -46,8 +54,8 @@
  private:
   class WidgetDelegate;
 
-  views::Widget* widget_ = nullptr;
-  std::unique_ptr<WidgetDelegate> delegate_;
+  // The widget created using |ShowWidgetWithContent|.
+  std::unique_ptr<views::Widget> widget_;
 
   std::vector<mojom::LoginUserInfoPtr> users_;
 
diff --git a/ash/login/ui/login_user_view_unittest.cc b/ash/login/ui/login_user_view_unittest.cc
index 8d5e984..f066da6 100644
--- a/ash/login/ui/login_user_view_unittest.cc
+++ b/ash/login/ui/login_user_view_unittest.cc
@@ -45,7 +45,7 @@
     auto* root = new views::View();
     root->SetLayoutManager(new views::BoxLayout(views::BoxLayout::kHorizontal));
     root->AddChildView(container_);
-    ShowWidgetWithContent(root);
+    SetWidget(CreateWidgetWithContent(root));
   }
 
   int tap_count_ = 0;
@@ -229,4 +229,4 @@
   EXPECT_TRUE(two_test.is_opaque());
 }
 
-}  // namespace ash
\ No newline at end of file
+}  // namespace ash
diff --git a/ash/login/ui/note_action_launch_button_unittest.cc b/ash/login/ui/note_action_launch_button_unittest.cc
index 685d3f3..08ab207 100644
--- a/ash/login/ui/note_action_launch_button_unittest.cc
+++ b/ash/login/ui/note_action_launch_button_unittest.cc
@@ -19,6 +19,7 @@
 #include "ui/gfx/geometry/vector2d.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/view.h"
+#include "ui/views/widget/widget.h"
 
 namespace ash {
 
@@ -47,10 +48,6 @@
 
   TestTrayActionClient* tray_action_client() { return &tray_action_client_; }
 
-  void ShowNoteActionView(NoteActionLaunchButton* note_action) {
-    ShowWidgetWithContent(
-        login_layout_util::WrapViewForPreferredSize(note_action));
-  }
 
   void PerformClick(const gfx::Point& point) {
     ui::test::EventGenerator& generator = GetEventGenerator();
@@ -95,7 +92,8 @@
 TEST_F(NoteActionLaunchButtonTest, StateChanges) {
   auto* note_action_button = new NoteActionLaunchButton(
       mojom::TrayActionState::kAvailable, data_dispatcher());
-  ShowNoteActionView(note_action_button);
+  std::unique_ptr<views::Widget> widget = CreateWidgetWithContent(
+      login_layout_util::WrapViewForPreferredSize(note_action_button));
   NoteActionLaunchButton::TestApi test_api(note_action_button);
 
   // In kAvailable state, the action button should be visible.
@@ -133,7 +131,8 @@
 TEST_F(NoteActionLaunchButtonTest, KeyboardTest) {
   auto* note_action_button = new NoteActionLaunchButton(
       mojom::TrayActionState::kAvailable, data_dispatcher());
-  ShowNoteActionView(note_action_button);
+  std::unique_ptr<views::Widget> widget = CreateWidgetWithContent(
+      login_layout_util::WrapViewForPreferredSize(note_action_button));
   NoteActionLaunchButton::TestApi test_api(note_action_button);
 
   note_action_button->RequestFocus();
@@ -157,7 +156,8 @@
 TEST_F(NoteActionLaunchButtonTest, ClickTest) {
   auto* note_action_button = new NoteActionLaunchButton(
       mojom::TrayActionState::kAvailable, data_dispatcher());
-  ShowNoteActionView(note_action_button);
+  std::unique_ptr<views::Widget> widget = CreateWidgetWithContent(
+      login_layout_util::WrapViewForPreferredSize(note_action_button));
 
   const gfx::Size action_size = note_action_button->GetPreferredSize();
   EXPECT_EQ(gfx::Size(kLargeButtonRadiusDp, kLargeButtonRadiusDp), action_size);
diff --git a/ash/public/interfaces/lock_screen.mojom b/ash/public/interfaces/lock_screen.mojom
index b13801f..5a5155b 100644
--- a/ash/public/interfaces/lock_screen.mojom
+++ b/ash/public/interfaces/lock_screen.mojom
@@ -60,6 +60,11 @@
   // |account_id|:   The account id of the user in the user pod.
   // |is_enabled|:   True if pin unlock is enabled.
   SetPinEnabledForUser(signin.mojom.AccountId account_id, bool is_enabled);
+
+  // Called when focus is reported to be leaving a lock screen app window.
+  // Requests focus to be handed off to the next suitable widget.
+  // |reverse|:   Whether the tab order is reversed.
+  HandleFocusLeavingLockScreenApps(bool reverse);
 };
 
 // Allows ash lock screen to control a client (e.g. Chrome browser). Requests
@@ -108,4 +113,12 @@
 
   // User with |account_id| has reached maximum incorrect password attempts.
   OnMaxIncorrectPasswordAttempted(signin.mojom.AccountId account_id);
+
+  // Should pass the focus to the active lock screen app window, if there is
+  // one. This is called when a lock screen app is reported to be active (using
+  // tray_action mojo interface), and is next in the tab order.
+  // |HandleFocusLeavingLockScreenApps| should be called to return focus to the
+  // lock screen.
+  // |reverse|:   Whether the tab order is reversed.
+  FocusLockScreenApps(bool reverse);
 };
diff --git a/chrome/browser/chromeos/login/lock/views_screen_locker.cc b/chrome/browser/chromeos/login/lock/views_screen_locker.cc
index 08d7329..fae53fb 100644
--- a/chrome/browser/chromeos/login/lock/views_screen_locker.cc
+++ b/chrome/browser/chromeos/login/lock/views_screen_locker.cc
@@ -9,6 +9,7 @@
 #include "base/i18n/time_formatting.h"
 #include "base/metrics/histogram_macros.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/chromeos/lock_screen_apps/state_controller.h"
 #include "chrome/browser/chromeos/login/lock_screen_utils.h"
 #include "chrome/browser/chromeos/login/quick_unlock/quick_unlock_factory.h"
 #include "chrome/browser/chromeos/login/quick_unlock/quick_unlock_storage.h"
@@ -46,6 +47,8 @@
 }
 
 ViewsScreenLocker::~ViewsScreenLocker() {
+  if (lock_screen_apps::StateController::IsEnabled())
+    lock_screen_apps::StateController::Get()->SetFocusCyclerDelegate(nullptr);
   LockScreenClient::Get()->SetDelegate(nullptr);
 }
 
@@ -77,6 +80,8 @@
   UMA_HISTOGRAM_TIMES("LockScreen.LockReady",
                       base::TimeTicks::Now() - lock_time_);
   screen_locker_->ScreenLockReady();
+  if (lock_screen_apps::StateController::IsEnabled())
+    lock_screen_apps::StateController::Get()->SetFocusCyclerDelegate(this);
   OnAllowedInputMethodsChanged();
 }
 
@@ -201,6 +206,14 @@
   lock_screen_utils::EnforcePolicyInputMethods(std::string());
 }
 
+bool ViewsScreenLocker::HandleFocusLockScreenApps(bool reverse) {
+  if (lock_screen_app_focus_handler_.is_null())
+    return false;
+
+  lock_screen_app_focus_handler_.Run(reverse);
+  return true;
+}
+
 void ViewsScreenLocker::SuspendDone(const base::TimeDelta& sleep_duration) {
   for (user_manager::User* user :
        user_manager::UserManager::Get()->GetUnlockUsers()) {
@@ -208,6 +221,19 @@
   }
 }
 
+void ViewsScreenLocker::RegisterLockScreenAppFocusHandler(
+    const LockScreenAppFocusCallback& focus_handler) {
+  lock_screen_app_focus_handler_ = focus_handler;
+}
+
+void ViewsScreenLocker::UnregisterLockScreenAppFocusHandler() {
+  lock_screen_app_focus_handler_.Reset();
+}
+
+void ViewsScreenLocker::HandleLockScreenAppFocusOut(bool reverse) {
+  LockScreenClient::Get()->HandleFocusLeavingLockScreenApps(reverse);
+}
+
 void ViewsScreenLocker::UpdatePinKeyboardState(const AccountId& account_id) {
   quick_unlock::QuickUnlockStorage* quick_unlock_storage =
       quick_unlock::QuickUnlockFactory::GetForAccountId(account_id);
diff --git a/chrome/browser/chromeos/login/lock/views_screen_locker.h b/chrome/browser/chromeos/login/lock/views_screen_locker.h
index a7f692a..45b27eca 100644
--- a/chrome/browser/chromeos/login/lock/views_screen_locker.h
+++ b/chrome/browser/chromeos/login/lock/views_screen_locker.h
@@ -6,6 +6,7 @@
 #define CHROME_BROWSER_CHROMEOS_LOGIN_LOCK_VIEWS_SCREEN_LOCKER_H_
 
 #include "base/memory/weak_ptr.h"
+#include "chrome/browser/chromeos/lock_screen_apps/focus_cycler_delegate.h"
 #include "chrome/browser/chromeos/login/lock/screen_locker.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/ui/ash/lock_screen_client.h"
@@ -22,7 +23,8 @@
 // ash (views-based lockscreen).
 class ViewsScreenLocker : public LockScreenClient::Delegate,
                           public ScreenLocker::Delegate,
-                          public PowerManagerClient::Observer {
+                          public PowerManagerClient::Observer,
+                          public lock_screen_apps::FocusCyclerDelegate {
  public:
   explicit ViewsScreenLocker(ScreenLocker* screen_locker);
   ~ViewsScreenLocker() override;
@@ -54,10 +56,17 @@
   void HandleRecordClickOnLockIcon(const AccountId& account_id) override;
   void HandleOnFocusPod(const AccountId& account_id) override;
   void HandleOnNoPodFocused() override;
+  bool HandleFocusLockScreenApps(bool reverse) override;
 
   // PowerManagerClient::Observer:
   void SuspendDone(const base::TimeDelta& sleep_duration) override;
 
+  // lock_screen_apps::FocusCyclerDelegate:
+  void RegisterLockScreenAppFocusHandler(
+      const LockScreenAppFocusCallback& focus_handler) override;
+  void UnregisterLockScreenAppFocusHandler() override;
+  void HandleLockScreenAppFocusOut(bool reverse) override;
+
  private:
   void UpdatePinKeyboardState(const AccountId& account_id);
   void OnAllowedInputMethodsChanged();
@@ -81,6 +90,10 @@
 
   bool lock_screen_ready_ = false;
 
+  // Callback registered as a lock screen apps focus handler - it should be
+  // called to hand focus over to lock screen apps.
+  LockScreenAppFocusCallback lock_screen_app_focus_handler_;
+
   base::WeakPtrFactory<ViewsScreenLocker> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ViewsScreenLocker);
diff --git a/chrome/browser/ui/ash/lock_screen_client.cc b/chrome/browser/ui/ash/lock_screen_client.cc
index af8804bb..02a8ad4 100644
--- a/chrome/browser/ui/ash/lock_screen_client.cc
+++ b/chrome/browser/ui/ash/lock_screen_client.cc
@@ -83,6 +83,14 @@
     delegate_->HandleOnNoPodFocused();
 }
 
+void LockScreenClient::FocusLockScreenApps(bool reverse) {
+  // If delegate is not set, or it fails to handle focus request, call
+  // |HandleFocusLeavingLockScreenApps| so the lock screen mojo service can
+  // give focus to the next window in the tab order.
+  if (!delegate_ || !delegate_->HandleFocusLockScreenApps(reverse))
+    HandleFocusLeavingLockScreenApps(reverse);
+}
+
 void LockScreenClient::LoadWallpaper(const AccountId& account_id) {
   chromeos::WallpaperManager::Get()->SetUserWallpaperDelayed(account_id);
 }
@@ -140,6 +148,10 @@
   lock_screen_->SetPinEnabledForUser(account_id, is_enabled);
 }
 
+void LockScreenClient::HandleFocusLeavingLockScreenApps(bool reverse) {
+  lock_screen_->HandleFocusLeavingLockScreenApps(reverse);
+}
+
 void LockScreenClient::SetDelegate(Delegate* delegate) {
   delegate_ = delegate;
 }
diff --git a/chrome/browser/ui/ash/lock_screen_client.h b/chrome/browser/ui/ash/lock_screen_client.h
index 52ade92..ca38dd6 100644
--- a/chrome/browser/ui/ash/lock_screen_client.h
+++ b/chrome/browser/ui/ash/lock_screen_client.h
@@ -34,6 +34,10 @@
     virtual void HandleRecordClickOnLockIcon(const AccountId& account_id) = 0;
     virtual void HandleOnFocusPod(const AccountId& account_id) = 0;
     virtual void HandleOnNoPodFocused() = 0;
+    // Handles request to focus a lock screen app window. Returns whether the
+    // focus has been handed over to a lock screen app. For example, this might
+    // fail if a hander for lock screen apps focus has not been set.
+    virtual bool HandleFocusLockScreenApps(bool reverse) = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Delegate);
@@ -55,6 +59,7 @@
   void SignOutUser() override;
   void CancelAddUser() override;
   void OnMaxIncorrectPasswordAttempted(const AccountId& account_id) override;
+  void FocusLockScreenApps(bool reverse) override;
 
   // Wrappers around the mojom::LockScreen interface.
   void ShowLockScreen(ash::mojom::LockScreen::ShowLockScreenCallback on_shown);
@@ -72,6 +77,7 @@
   void LoadUsers(std::vector<ash::mojom::LoginUserInfoPtr> users_list,
                  bool show_guest);
   void SetPinEnabledForUser(const AccountId& account_id, bool is_enabled);
+  void HandleFocusLeavingLockScreenApps(bool reverse);
 
   void SetDelegate(Delegate* delegate);