Implement ScreenOrientationDelegate on ChromeOS

content/public/browser/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/renderer_host/render_view_host_delegate.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/screen_orientation_delegate.h"
 #include "content/public/browser/screen_orientation_dispatcher_host.h"
@@ skipping 54 matching lines @@
   if (lock_orientation == blink::WebScreenOrientationLockNatural) {
     lock_orientation = GetNaturalLockType();
     if (lock_orientation == blink::WebScreenOrientationLockDefault) {
       // We are in a broken state, let's pretend we got canceled.
       dispatcher_->NotifyLockError(request_id,
                                    blink::WebLockOrientationErrorCanceled);
       return;
     }
   }
 
-  lock_applied_ = true;
-  delegate_->Lock(lock_orientation);
+  lock_applied_ = delegate_->Lock(web_contents(), lock_orientation);

[mlamouri (slow - plz ping), 2014/11/01 00:30:40]

I'm really uncomfortable with that change especially because it is driven by
temporary code. If the implementation was complete, you wouldn't need that,
right? In that case, could you keep a broken but not exposed implementation? For
example, lock would always appear as unsupported unless experimental web
features is enabled?

[jonross, 2014/11/03 18:22:03]

That SGTM.

I'll reset the delegate to always Lock. The partial implementation in ash will
be hidden behind the flag we use for TouchView experiments. (Which is currently
the only state where we will support the functionality)

The web experiments flag is not exposed to ash, and exposing it for a temporary
change does not feel right.

+  if (!lock_applied_) {
+    // The delegate was unable to lock, cancel.
+    dispatcher_->NotifyLockError(request_id,
+                                 blink::WebLockOrientationErrorCanceled);
+    return;
+  }
 
   // If two calls happen close to each other some platforms will ignore the
   // first. A successful lock will be once orientation matches the latest
   // request.
   pending_lock_.reset();
 
   // If the orientation we are locking to matches the current orientation, we
   // should succeed immediately.
   if (LockMatchesCurrentOrientation(lock_orientation)) {
     dispatcher_->NotifyLockSuccess(request_id);
     return;
   }
 
   pending_lock_.reset(new LockInformation(request_id, lock_orientation));
 }
 
 void ScreenOrientationProvider::UnlockOrientation() {
   if (!lock_applied_ || !delegate_)
     return;
 
-  delegate_->Unlock();
+  delegate_->Unlock(web_contents());
 
   lock_applied_ = false;
   pending_lock_.reset();
 }
 
 void ScreenOrientationProvider::OnOrientationChange() {
   if (!pending_lock_.get())
     return;
 
   if (LockMatchesCurrentOrientation(pending_lock_->lock)) {
@@ skipping 92 matching lines @@
     case blink::WebScreenOrientationLockDefault:
       NOTREACHED();
       return false;
   }
 
   NOTREACHED();
   return false;
 }
 
 } // namespace content