Add VideoPacket struct for video packets. Refactor Decode interface to use it.

remoting/client/chromoting_client.cc

 // Copyright (c) 2010 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 "remoting/client/chromoting_client.h"
 
 #include "base/message_loop.h"
 #include "remoting/base/tracer.h"
 #include "remoting/client/chromoting_view.h"
 #include "remoting/client/client_context.h"
 #include "remoting/client/input_handler.h"
 #include "remoting/client/rectangle_update_decoder.h"
 #include "remoting/proto/internal.pb.h"
 #include "remoting/protocol/connection_to_host.h"
+#include "remoting/protocol/session_config.h"
 
 namespace remoting {
 
 ChromotingClient::ChromotingClient(const ClientConfig& config,
                                    ClientContext* context,
                                    protocol::ConnectionToHost* connection,
                                    ChromotingView* view,
                                    RectangleUpdateDecoder* rectangle_decoder,
                                    InputHandler* input_handler,
                                    CancelableTask* client_done)
@@ skipping 62 matching lines @@
     message_loop()->PostTask(
         FROM_HERE,
         NewRunnableMethod(this, &ChromotingClient::SetViewport,
                           x, y, width, height));
     return;
   }
 
   view_->SetViewport(x, y, width, height);
 }
 
-void ChromotingClient::HandleMessage(protocol::ConnectionToHost* conn,
-                                     ChromotingHostMessage* msg) {
-  if (message_loop() != MessageLoop::current()) {
-    message_loop()->PostTask(
-        FROM_HERE,
-        NewRunnableMethod(this, &ChromotingClient::HandleMessage,
-                          conn, msg));
-    return;
-  }
-
-  // TODO(ajwong): Consider creating a macro similar to the IPC message
-  // mappings.  Also reconsider the lifetime of the message object.
-  if (msg->has_init_client()) {
-    ScopedTracer tracer("Handle Init Client");
-    InitClient(msg->init_client());
-    delete msg;
-  } else {
-    NOTREACHED() << "Unknown message received";
-  }
-}
-
 void ChromotingClient::ProcessVideoPacket(const VideoPacket* packet,
                                           Task* done) {
   if (message_loop() != MessageLoop::current()) {
     message_loop()->PostTask(
         FROM_HERE,
         NewRunnableMethod(this, &ChromotingClient::ProcessVideoPacket,
                           packet, done));
     return;
   }
 
   received_packets_.push_back(QueuedVideoPacket(packet, done));
   if (!packet_being_processed_)
     DispatchPacket();
 }
 
 void ChromotingClient::DispatchPacket() {
   DCHECK_EQ(message_loop(), MessageLoop::current());
   CHECK(!packet_being_processed_);
 
   if (received_packets_.empty()) {
     // Nothing to do!
     return;
   }
 
   const VideoPacket* packet = received_packets_.front().packet;
   packet_being_processed_ = true;
 
   ScopedTracer tracer("Handle video packet");
   rectangle_decoder_->DecodePacket(
-      *packet, NewTracedMethod(this, &ChromotingClient::OnPacketDone));
+      packet, NewTracedMethod(this, &ChromotingClient::OnPacketDone));
 }
 
 void ChromotingClient::OnConnectionOpened(protocol::ConnectionToHost* conn) {
   VLOG(1) << "ChromotingClient::OnConnectionOpened";
   SetConnectionState(CONNECTED);
+  Initialize();
 }
 
 void ChromotingClient::OnConnectionClosed(protocol::ConnectionToHost* conn) {
   VLOG(1) << "ChromotingClient::OnConnectionClosed";
   SetConnectionState(DISCONNECTED);
 }
 
 void ChromotingClient::OnConnectionFailed(protocol::ConnectionToHost* conn) {
   VLOG(1) << "ChromotingClient::OnConnectionFailed";
   SetConnectionState(FAILED);
@@ skipping 31 matching lines @@
 
   received_packets_.front().done->Run();
   delete received_packets_.front().done;
   received_packets_.pop_front();
 
   packet_being_processed_ = false;
 
   DispatchPacket();
 }
 
-void ChromotingClient::InitClient(const InitClientMessage& init_client) {
-  DCHECK_EQ(message_loop(), MessageLoop::current());
-  TraceContext::tracer()->PrintString("Init received");
+void ChromotingClient::Initialize() {
+  if (message_loop() != MessageLoop::current()) {
+    message_loop()->PostTask(
+        FROM_HERE,
+        NewTracedMethod(this, &ChromotingClient::Initialize));
+    return;
+  }
+
+  TraceContext::tracer()->PrintString("Initializing client.");
+
+  const protocol::SessionConfig* config = connection_->config();
 
   // Resize the window.
-  int width = init_client.width();
-  int height = init_client.height();
-  VLOG(1) << "Init client received geometry: " << width << "x" << height;
+  int width = config->initial_resolution().width;
+  int height = config->initial_resolution().height;
+  VLOG(1) << "Initial screen geometry: " << width << "x" << height;
 
-//  TODO(ajwong): What to do here?  Does the decoder actually need to request
-//  the right frame size?  This is mainly an optimization right?
-//  rectangle_decoder_->SetOutputFrameSize(width, height);
+  // TODO(ajwong): What to do here?  Does the decoder actually need to request
+  // the right frame size?  This is mainly an optimization right?
+  // rectangle_decoder_->SetOutputFrameSize(width, height);
   view_->SetViewport(0, 0, width, height);
 
+  // Initialize the decoder.
+  rectangle_decoder_->Initialize(config);
+
   // Schedule the input handler to process the event queue.
   input_handler_->Initialize();
 }
 
 }  // namespace remoting