[For trybots test] [ScreenOrientation] Hide ScreenOrientationProvider inside WebContentsImpl.

content/browser/screen_orientation/screen_orientation_provider.cc

 // Copyright 2014 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 "content/public/browser/screen_orientation_provider.h"
+#include "content/browser/screen_orientation/screen_orientation_provider.h"
 
 #include "base/callback_helpers.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
+#include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/screen_orientation_delegate.h"
 #include "content/public/browser/web_contents.h"
 #include "third_party/WebKit/public/platform/modules/screen_orientation/WebLockOrientationError.h"
 
 namespace content {
 
 using device::mojom::ScreenOrientationLockResult;
 
 ScreenOrientationDelegate* ScreenOrientationProvider::delegate_ = nullptr;
 
 ScreenOrientationProvider::ScreenOrientationProvider(WebContents* web_contents)
-    : WebContentsObserver(web_contents), lock_applied_(false) {}
+    : WebContentsObserver(web_contents),
+      lock_applied_(false),
+      bindings_(web_contents, this) {}
 
-ScreenOrientationProvider::~ScreenOrientationProvider() {
-}
+ScreenOrientationProvider::~ScreenOrientationProvider() = default;
 
 void ScreenOrientationProvider::LockOrientation(
     blink::WebScreenOrientationLockType orientation,
     const LockOrientationCallback& callback) {
   // Cancel any pending lock request.
   NotifyLockResult(ScreenOrientationLockResult::
                        SCREEN_ORIENTATION_LOCK_RESULT_ERROR_CANCELED);
   // Record new pending lock request.
   pending_callback_ = callback;
 
@@ skipping 63 matching lines @@
 
   if (LockMatchesCurrentOrientation(pending_lock_orientation_.value())) {
     DCHECK(!pending_callback_.is_null());
     NotifyLockResult(
         ScreenOrientationLockResult::SCREEN_ORIENTATION_LOCK_RESULT_SUCCESS);
   }
 }
 
 void ScreenOrientationProvider::NotifyLockResult(
     ScreenOrientationLockResult result) {
-  if (!pending_callback_.is_null()) {
+  if (!pending_callback_.is_null())
     base::ResetAndReturn(&pending_callback_).Run(result);
-  }
+
   pending_lock_orientation_.reset();
 }
 
 void ScreenOrientationProvider::SetDelegate(
     ScreenOrientationDelegate* delegate) {
   delegate_ = delegate;
 }
 
 void ScreenOrientationProvider::DidToggleFullscreenModeForTab(
-    bool entered_fullscreen, bool will_cause_resize) {
+    bool entered_fullscreen,
+    bool will_cause_resize) {
   if (!lock_applied_ || !delegate_)
     return;
 
   // If fullscreen is not required in order to lock orientation, don't unlock
   // when fullscreen state changes.
   if (!delegate_->FullScreenRequired(web_contents()))
     return;
 
   DCHECK(!entered_fullscreen);
   UnlockOrientation();
 }
 
+void ScreenOrientationProvider::DidFinishNavigation(
+    NavigationHandle* navigation_handle) {
+  if (!navigation_handle->IsInMainFrame() ||
+      !navigation_handle->HasCommitted() || navigation_handle->IsSamePage()) {
+    return;
+  }
+  UnlockOrientation();
+}
+
 blink::WebScreenOrientationLockType
-    ScreenOrientationProvider::GetNaturalLockType() const {
+ScreenOrientationProvider::GetNaturalLockType() const {
   RenderWidgetHost* rwh = web_contents()->GetRenderViewHost()->GetWidget();
   if (!rwh)
     return blink::WebScreenOrientationLockDefault;
 
   ScreenInfo screen_info;
   rwh->GetScreenInfo(&screen_info);
 
   switch (screen_info.orientation_type) {
     case SCREEN_ORIENTATION_VALUES_PORTRAIT_PRIMARY:
     case SCREEN_ORIENTATION_VALUES_PORTRAIT_SECONDARY:
@@ skipping 22 matching lines @@
   RenderWidgetHost* rwh = web_contents()->GetRenderViewHost()->GetWidget();
   if (!rwh)
     return false;
 
   ScreenInfo screen_info;
   rwh->GetScreenInfo(&screen_info);
 
   switch (lock) {
     case blink::WebScreenOrientationLockPortraitPrimary:
       return screen_info.orientation_type ==
-          SCREEN_ORIENTATION_VALUES_PORTRAIT_PRIMARY;
+             SCREEN_ORIENTATION_VALUES_PORTRAIT_PRIMARY;
     case blink::WebScreenOrientationLockPortraitSecondary:
       return screen_info.orientation_type ==
-          SCREEN_ORIENTATION_VALUES_PORTRAIT_SECONDARY;
+             SCREEN_ORIENTATION_VALUES_PORTRAIT_SECONDARY;
     case blink::WebScreenOrientationLockLandscapePrimary:
       return screen_info.orientation_type ==
-          SCREEN_ORIENTATION_VALUES_LANDSCAPE_PRIMARY;
+             SCREEN_ORIENTATION_VALUES_LANDSCAPE_PRIMARY;
     case blink::WebScreenOrientationLockLandscapeSecondary:
       return screen_info.orientation_type ==
-          SCREEN_ORIENTATION_VALUES_LANDSCAPE_SECONDARY;
+             SCREEN_ORIENTATION_VALUES_LANDSCAPE_SECONDARY;
     case blink::WebScreenOrientationLockLandscape:
       return screen_info.orientation_type ==
-          SCREEN_ORIENTATION_VALUES_LANDSCAPE_PRIMARY ||
-          screen_info.orientation_type ==
-          SCREEN_ORIENTATION_VALUES_LANDSCAPE_SECONDARY;
+                 SCREEN_ORIENTATION_VALUES_LANDSCAPE_PRIMARY ||
+             screen_info.orientation_type ==
+                 SCREEN_ORIENTATION_VALUES_LANDSCAPE_SECONDARY;
     case blink::WebScreenOrientationLockPortrait:
       return screen_info.orientation_type ==
-          SCREEN_ORIENTATION_VALUES_PORTRAIT_PRIMARY ||
-          screen_info.orientation_type ==
-          SCREEN_ORIENTATION_VALUES_PORTRAIT_SECONDARY;
+                 SCREEN_ORIENTATION_VALUES_PORTRAIT_PRIMARY ||
+             screen_info.orientation_type ==
+                 SCREEN_ORIENTATION_VALUES_PORTRAIT_SECONDARY;
     case blink::WebScreenOrientationLockAny:
       return true;
     case blink::WebScreenOrientationLockNatural:
     case blink::WebScreenOrientationLockDefault:
       NOTREACHED();
       return false;
   }
 
   NOTREACHED();
   return false;
 }
 
-} // namespace content
+}  // namespace content