Properly route screen orientation IPC messages.

content/renderer/screen_orientation/screen_orientation_dispatcher_unittest.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 "screen_orientation_dispatcher.h"
 
 #include <list>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 87 matching lines @@
   }
 
   void UnlockOrientation() {
     dispatcher_->unlockOrientation();
   }
 
   void OnMessageReceived(const IPC::Message& message) {
     dispatcher_->OnMessageReceived(message);
   }
 
+  int routing_id() const {
+    // We return a fake routing_id() in the context of this test.
+    return 0;
+  }
+
   IPC::TestSink sink_;
   scoped_ptr<ScreenOrientationDispatcher> dispatcher_;
 };
 
 // Test that calling lockOrientation() followed by unlockOrientation() cancel
 // the lockOrientation().
 TEST_F(ScreenOrientationDispatcherTest, CancelPending_Unlocking) {
   MockLockOrientationCallback::LockOrientationResultHolder callback_results;
   LockOrientation(blink::WebScreenOrientationLockPortraitPrimary,
                   new MockLockOrientationCallback(&callback_results));
@@ skipping 31 matching lines @@
       blink::WebLockOrientationCallback::ErrorTypeFullScreenRequired);
   errors.push_back(blink::WebLockOrientationCallback::ErrorTypeCanceled);
 
   for (std::list<blink::WebLockOrientationCallback::ErrorType>::const_iterator
           it = errors.begin(); it != errors.end(); ++it) {
     MockLockOrientationCallback::LockOrientationResultHolder callback_results;
     LockOrientation(blink::WebScreenOrientationLockPortraitPrimary,
                     new MockLockOrientationCallback(&callback_results));
 
     int request_id = GetFirstLockRequestIdFromSink();
-    OnMessageReceived(ScreenOrientationMsg_LockError(request_id, *it));
+    OnMessageReceived(
+        ScreenOrientationMsg_LockError(routing_id(), request_id, *it));
 
     EXPECT_FALSE(callback_results.succeeded_);
     EXPECT_TRUE(callback_results.failed_);
     EXPECT_EQ(*it, callback_results.error_);
 
     sink().ClearMessages();
   }
 }
 
 // Test that when a LockSuccess message is received, the request is set as
@@ skipping 10 matching lines @@
   };
 
   int orientationsCount = 4;
 
   for (int i = 0; i < orientationsCount; ++i) {
     MockLockOrientationCallback::LockOrientationResultHolder callback_results;
     LockOrientation(blink::WebScreenOrientationLockPortraitPrimary,
                     new MockLockOrientationCallback(&callback_results));
 
     int request_id = GetFirstLockRequestIdFromSink();
-    OnMessageReceived(ScreenOrientationMsg_LockSuccess(request_id,
+    OnMessageReceived(ScreenOrientationMsg_LockSuccess(routing_id(),
+                                                       request_id,
                                                        orientations[i].angle,
                                                        orientations[i].type));
 
     EXPECT_TRUE(callback_results.succeeded_);
     EXPECT_FALSE(callback_results.failed_);
     EXPECT_EQ(orientations[i].angle, callback_results.angle_);
     EXPECT_EQ(orientations[i].type, callback_results.orientation_);
 
     sink().ClearMessages();
   }
 }
 
 // Test an edge case: a LockSuccess is received but it matches no pending
 // callback.
 TEST_F(ScreenOrientationDispatcherTest, SuccessForUnknownRequest) {
   MockLockOrientationCallback::LockOrientationResultHolder callback_results;
   LockOrientation(blink::WebScreenOrientationLockPortraitPrimary,
                   new MockLockOrientationCallback(&callback_results));
 
   int request_id = GetFirstLockRequestIdFromSink();
   OnMessageReceived(ScreenOrientationMsg_LockSuccess(
+      routing_id(),
       request_id + 1,
       90,
       blink::WebScreenOrientationLandscapePrimary));
 
   EXPECT_FALSE(callback_results.succeeded_);
   EXPECT_FALSE(callback_results.failed_);
 }
 
 // Test an edge case: a LockError is received but it matches no pending
 // callback.
 TEST_F(ScreenOrientationDispatcherTest, ErrorForUnknownRequest) {
   MockLockOrientationCallback::LockOrientationResultHolder callback_results;
   LockOrientation(blink::WebScreenOrientationLockPortraitPrimary,
                   new MockLockOrientationCallback(&callback_results));
 
   int request_id = GetFirstLockRequestIdFromSink();
   OnMessageReceived(ScreenOrientationMsg_LockError(
+      routing_id(),
       request_id + 1,
       blink::WebLockOrientationCallback::ErrorTypeCanceled));
 
   EXPECT_FALSE(callback_results.succeeded_);
   EXPECT_FALSE(callback_results.failed_);
 }
 
 // Test the following scenario:
 // - request1 is received by the dispatcher;
 // - request2 is received by the dispatcher;
 // - request1 is rejected;
 // - request1 success response is received.
 // Expected: request1 is still rejected, request2 has not been set as succeeded.
 TEST_F(ScreenOrientationDispatcherTest, RaceScenario) {
   MockLockOrientationCallback::LockOrientationResultHolder callback_results1;
   MockLockOrientationCallback::LockOrientationResultHolder callback_results2;
 
   LockOrientation(blink::WebScreenOrientationLockPortraitPrimary,
                   new MockLockOrientationCallback(&callback_results1));
   int request_id1 = GetFirstLockRequestIdFromSink();
 
   LockOrientation(blink::WebScreenOrientationLockLandscapePrimary,
                   new MockLockOrientationCallback(&callback_results2));
 
   // callback_results1 must be rejected, tested in CancelPending_DoubleLock.
 
   OnMessageReceived(ScreenOrientationMsg_LockSuccess(
+      routing_id(),
       request_id1,
       0,
       blink::WebScreenOrientationPortraitPrimary));
 
   // First request is still rejected.
   EXPECT_FALSE(callback_results1.succeeded_);
   EXPECT_TRUE(callback_results1.failed_);
   EXPECT_EQ(blink::WebLockOrientationCallback::ErrorTypeCanceled,
             callback_results1.error_);
 
   // Second request is still pending.
   EXPECT_FALSE(callback_results2.succeeded_);
   EXPECT_FALSE(callback_results2.failed_);
 }
 
 }  // namespace content