[blimp] Add support for having multiple tabs

blimp/client/core/compositor/blimp_compositor_manager_unittest.cc

 // Copyright 2016 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 "blimp/client/core/compositor/blimp_compositor_manager.h"
 
 #include "base/memory/ptr_util.h"
 #include "blimp/client/core/compositor/blimp_compositor_dependencies.h"
 #include "blimp/client/core/compositor/blob_image_serialization_processor.h"
 #include "blimp/client/support/compositor/mock_compositor_dependencies.h"
 #include "cc/proto/compositor_message.pb.h"
 #include "cc/surfaces/surface_manager.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/gesture_detection/motion_event_generic.h"
 
 using testing::_;
 using testing::InSequence;
 using testing::Sequence;
 
 namespace blimp {
 namespace client {
 namespace {
 
+const int kDummyBlimpContentsId = 0;
+
 class MockRenderWidgetFeature : public RenderWidgetFeature {
  public:
   MOCK_METHOD3(SendCompositorMessage,
                void(const int, const int, const cc::proto::CompositorMessage&));
   MOCK_METHOD3(SendInputEvent,
                void(const int, const int, const blink::WebInputEvent&));
   MOCK_METHOD2(SetDelegate, void(int, RenderWidgetFeatureDelegate*));
   MOCK_METHOD1(RemoveDelegate, void(const int));
 };
 
@@ skipping 12 matching lines @@
       std::unique_ptr<cc::proto::CompositorMessage> message) override {
     MockableOnCompositorMessageReceived(*message);
   }
   MOCK_METHOD1(MockableOnCompositorMessageReceived,
                void(const cc::proto::CompositorMessage&));
 };
 
 class BlimpCompositorManagerForTesting : public BlimpCompositorManager {
  public:
   explicit BlimpCompositorManagerForTesting(
+      int blimp_contents_id,
       RenderWidgetFeature* render_widget_feature,
       BlimpCompositorDependencies* compositor_dependencies)
-      : BlimpCompositorManager(render_widget_feature, compositor_dependencies) {
-  }
+      : BlimpCompositorManager(blimp_contents_id,
+                               render_widget_feature,
+                               compositor_dependencies) {}
 
   using BlimpCompositorManager::GetCompositor;
 
   std::unique_ptr<BlimpCompositor> CreateBlimpCompositor(
       int render_widget_id,
       BlimpCompositorDependencies* compositor_dependencies,
       BlimpCompositorClient* client) override {
     return base::MakeUnique<MockBlimpCompositor>(
         render_widget_id, compositor_dependencies, client);
   }
 };
 
 class BlimpCompositorManagerTest : public testing::Test {
  public:
   void SetUp() override {
     EXPECT_CALL(render_widget_feature_, SetDelegate(_, _)).Times(1);
     EXPECT_CALL(render_widget_feature_, RemoveDelegate(_)).Times(1);
 
     compositor_dependencies_ = base::MakeUnique<BlimpCompositorDependencies>(
         base::MakeUnique<MockCompositorDependencies>());
 
     compositor_manager_ = base::MakeUnique<BlimpCompositorManagerForTesting>(
-        &render_widget_feature_, compositor_dependencies_.get());
+        kDummyBlimpContentsId, &render_widget_feature_,
+        compositor_dependencies_.get());
   }
 
   void TearDown() override {
     mock_compositor1_ = nullptr;
     mock_compositor2_ = nullptr;
     compositor_manager_.reset();
     compositor_dependencies_.reset();
   }
 
   void SetUpCompositors() {
@@ skipping 83 matching lines @@
   // events forwarded after this.
   delegate()->OnRenderWidgetDeleted(1);
   delegate()->OnRenderWidgetDeleted(2);
 
   compositor_manager_->SetVisible(true);
 }
 
 }  // namespace
 }  // namespace client
 }  // namespace blimp