Fix crash in protocol perf test.

remoting/test/protocol_perftest.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 "base/base64.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 43 matching lines @@
         latency_stddev(base::TimeDelta::FromMillisecondsD(latency_stddev_ms)),
         out_of_order_rate(out_of_order_rate) {}
 
   int bandwidth;
   int max_buffers;
   base::TimeDelta latency_average;
   base::TimeDelta latency_stddev;
   double out_of_order_rate;
 };
 
+class FakeCursorShapeStub : public protocol::CursorShapeStub {
+ public:
+  FakeCursorShapeStub() {}
+  virtual ~FakeCursorShapeStub() {}
+
+  // protocol::CursorShapeStub interface.
+  virtual void SetCursorShape(
+      const protocol::CursorShapeInfo& cursor_shape) OVERRIDE {};
+};
+
 class ProtocolPerfTest
     : public testing::Test,
       public testing::WithParamInterface<NetworkPerformanceParams>,
       public ClientUserInterface,
       public VideoRenderer,
       public HostStatusObserver {
  public:
   ProtocolPerfTest()
       : host_thread_("host"),
         capture_thread_("capture"),
@@ skipping 27 matching lines @@
   }
   virtual void SetCapabilities(const std::string& capabilities) OVERRIDE {}
   virtual void SetPairingResponse(
       const protocol::PairingResponse& pairing_response) OVERRIDE {}
   virtual void DeliverHostMessage(
       const protocol::ExtensionMessage& message) OVERRIDE {}
   virtual protocol::ClipboardStub* GetClipboardStub() OVERRIDE {
     return NULL;
   }
   virtual protocol::CursorShapeStub* GetCursorShapeStub() OVERRIDE {
-    return NULL;
+    return &cursor_shape_stub_;
   }
 
   // VideoRenderer interface.
   virtual void Initialize(const protocol::SessionConfig& config) OVERRIDE {}
   virtual ChromotingStats* GetStats() OVERRIDE { return NULL; }
   virtual void ProcessVideoPacket(scoped_ptr<VideoPacket> video_packet,
                                   const base::Closure& done) OVERRIDE {
     if (video_packet->data().empty()) {
       // Ignore keep-alive packets
       done.Run();
@@ skipping 206 matching lines @@
 
   base::MessageLoopForIO message_loop_;
 
   scoped_refptr<FakeNetworkDispatcher> fake_network_dispatcher_;
 
   base::Thread host_thread_;
   base::Thread capture_thread_;
   base::Thread encode_thread_;
   FakeDesktopEnvironmentFactory desktop_environment_factory_;
 
+  FakeCursorShapeStub cursor_shape_stub_;
+
   scoped_ptr<protocol::CandidateSessionConfig> protocol_config_;
 
   scoped_ptr<FakeSignalStrategy> host_signaling_;
   scoped_ptr<FakeSignalStrategy> client_signaling_;
 
   scoped_ptr<ChromotingHost> host_;
   scoped_ptr<ClientContext> client_context_;
   scoped_ptr<ChromotingClient> client_;
 
   scoped_ptr<base::RunLoop> connecting_loop_;
@@ skipping 129 matching lines @@
               << "ms Encode: " << last_video_packet_->encode_time_ms()
               << "ms Capture: " << last_video_packet_->capture_time_ms()
               << "ms";
     sum += latency;
   }
 
   LOG(INFO) << "Average: " << (sum / kFrames).InMillisecondsF();
 }
 
 }  // namespace remoting