Upstream version 10.38.222.0

[platform/framework/web/crosswalk.git] / src / content / browser / screen_orientation / screen_orientation_dispatcher_host.cc

diff --git a/src/content/browser/screen_orientation/screen_orientation_dispatcher_host.cc b/src/content/browser/screen_orientation/screen_orientation_dispatcher_host.cc
index 5127c78..310b54b 100644 (file)
--- a/src/content/browser/screen_orientation/screen_orientation_dispatcher_host.cc
+++ b/src/content/browser/screen_orientation/screen_orientation_dispatcher_host.cc
@@ -6,63 +6,138 @@
 
 #include "content/browser/screen_orientation/screen_orientation_provider.h"
 #include "content/common/screen_orientation_messages.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_widget_host.h"
+#include "content/public/browser/web_contents.h"
+#include "third_party/WebKit/public/platform/WebScreenInfo.h"
 
 namespace content {
 
-ScreenOrientationDispatcherHost::ScreenOrientationDispatcherHost()
-  : BrowserMessageFilter(ScreenOrientationMsgStart) {
-  if (!provider_.get())
-    provider_.reset(CreateProvider());
+ScreenOrientationDispatcherHost::LockInformation::LockInformation(
+    int request_id, int process_id, int routing_id)
+    : request_id(request_id),
+      process_id(process_id),
+      routing_id(routing_id) {
+}
+
+ScreenOrientationDispatcherHost::ScreenOrientationDispatcherHost(
+    WebContents* web_contents)
+  : WebContentsObserver(web_contents),
+    current_lock_(NULL) {
+  provider_.reset(ScreenOrientationProvider::Create(this, web_contents));
 }
 
 ScreenOrientationDispatcherHost::~ScreenOrientationDispatcherHost() {
+  ResetCurrentLock();
+}
+
+void ScreenOrientationDispatcherHost::ResetCurrentLock() {
+  if (current_lock_) {
+    delete current_lock_;
+    current_lock_ = 0;
+  }
 }
 
 bool ScreenOrientationDispatcherHost::OnMessageReceived(
-    const IPC::Message& message, bool* message_was_ok) {
+    const IPC::Message& message,
+    RenderFrameHost* render_frame_host) {
   bool handled = true;
 
-  IPC_BEGIN_MESSAGE_MAP_EX(ScreenOrientationDispatcherHost,
-                           message,
-                           *message_was_ok)
-    IPC_MESSAGE_HANDLER(ScreenOrientationHostMsg_Lock, OnLockRequest)
+  IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(ScreenOrientationDispatcherHost, message,
+                                   render_frame_host)
+    IPC_MESSAGE_HANDLER(ScreenOrientationHostMsg_LockRequest, OnLockRequest)
     IPC_MESSAGE_HANDLER(ScreenOrientationHostMsg_Unlock, OnUnlockRequest)
     IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP_EX()
+  IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
-void ScreenOrientationDispatcherHost::OnOrientationChange(
-    blink::WebScreenOrientation orientation) {
-  Send(new ScreenOrientationMsg_OrientationChange(orientation));
+RenderFrameHost*
+ScreenOrientationDispatcherHost::GetRenderFrameHostForRequestID(
+    int request_id) {
+  if (!current_lock_ || current_lock_->request_id != request_id)
+    return NULL;
+
+  return RenderFrameHost::FromID(current_lock_->process_id,
+                                 current_lock_->routing_id);
 }
 
-void ScreenOrientationDispatcherHost::SetProviderForTests(
+void ScreenOrientationDispatcherHost::NotifyLockSuccess(int request_id) {
+  RenderFrameHost* render_frame_host =
+      GetRenderFrameHostForRequestID(request_id);
+  if (!render_frame_host)
+    return;
+
+  render_frame_host->Send(new ScreenOrientationMsg_LockSuccess(
+      render_frame_host->GetRoutingID(), request_id));
+  ResetCurrentLock();
+}
+
+void ScreenOrientationDispatcherHost::NotifyLockError(
+    int request_id, blink::WebLockOrientationError error) {
+  RenderFrameHost* render_frame_host =
+      GetRenderFrameHostForRequestID(request_id);
+  if (!render_frame_host)
+    return;
+
+  NotifyLockError(request_id, render_frame_host, error);
+}
+
+void ScreenOrientationDispatcherHost::NotifyLockError(
+    int request_id,
+    RenderFrameHost* render_frame_host,
+    blink::WebLockOrientationError error) {
+  render_frame_host->Send(new ScreenOrientationMsg_LockError(
+      render_frame_host->GetRoutingID(), request_id, error));
+  ResetCurrentLock();
+}
+
+void ScreenOrientationDispatcherHost::OnOrientationChange() {
+  if (provider_)
+    provider_->OnOrientationChange();
+}
+
+void ScreenOrientationDispatcherHost::SetProvider(
     ScreenOrientationProvider* provider) {
   provider_.reset(provider);
 }
 
 void ScreenOrientationDispatcherHost::OnLockRequest(
-    blink::WebScreenOrientations orientations) {
-  if (!provider_.get())
+    RenderFrameHost* render_frame_host,
+    blink::WebScreenOrientationLockType orientation,
+    int request_id) {
+  if (current_lock_) {
+    NotifyLockError(current_lock_->request_id, render_frame_host,
+                    blink::WebLockOrientationErrorCanceled);
+  }
+
+  if (!provider_) {
+    NotifyLockError(request_id, render_frame_host,
+                    blink::WebLockOrientationErrorNotAvailable);
     return;
+  }
+
+  current_lock_ = new LockInformation(request_id,
+                                      render_frame_host->GetProcess()->GetID(),
+                                      render_frame_host->GetRoutingID());
 
-  provider_->LockOrientation(orientations);
+  provider_->LockOrientation(request_id, orientation);
 }
 
-void ScreenOrientationDispatcherHost::OnUnlockRequest() {
-  if (!provider_.get())
+void ScreenOrientationDispatcherHost::OnUnlockRequest(
+    RenderFrameHost* render_frame_host) {
+  if (current_lock_) {
+    NotifyLockError(current_lock_->request_id, render_frame_host,
+                    blink::WebLockOrientationErrorCanceled);
+  }
+
+  if (!provider_)
     return;
 
   provider_->UnlockOrientation();
 }
 
-#if !defined(OS_ANDROID)
-// static
-ScreenOrientationProvider* ScreenOrientationDispatcherHost::CreateProvider() {
-  return NULL;
-}
-#endif
-
 }  // namespace content