Moving Encoder and Decoder to remoting/base

remoting/host/session_manager.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/host/session_manager.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "base/stl_util-inl.h"
 #include "media/base/data_buffer.h"
+#include "remoting/base/capture_data.h"
 #include "remoting/base/protocol_decoder.h"
 #include "remoting/host/client_connection.h"
-#include "remoting/host/encoder.h"
 
 namespace remoting {
 
 // By default we capture 20 times a second. This number is obtained by
 // experiment to provide good latency.
 static const double kDefaultCaptureRate = 20.0;
 
 // Interval that we perform rate regulation.
 static const base::TimeDelta kRateControlInterval =
     base::TimeDelta::FromSeconds(1);
@@ skipping 186 matching lines @@
 
   // TODO(dmaclach): make this not required on the Mac eventually.
   // Will require getting the X11client to work properly. Right now X11 expects
   // full screens each pass.
   capturer_->InvalidateFullScreen();
   capturer_->CaptureInvalidRects(
       NewCallback(this, &SessionManager::CaptureDoneCallback));
 }
 
 void SessionManager::CaptureDoneCallback(
-    scoped_refptr<Capturer::CaptureData> capture_data) {
+    scoped_refptr<CaptureData> capture_data) {
   // TODO(hclam): There is a bug if the capturer doesn't produce any dirty rects.
   DCHECK_EQ(capture_loop_, MessageLoop::current());
   encode_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &SessionManager::DoEncode, capture_data));
 }
 
 void SessionManager::DoFinishEncode() {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
@@ skipping 141 matching lines @@
 void SessionManager::DoRemoveAllClients() {
   DCHECK_EQ(network_loop_, MessageLoop::current());
 
   // Clear the list of clients.
   clients_.clear();
 }
 
 // Encoder thread --------------------------------------------------------------
 
 void SessionManager::DoEncode(
-    scoped_refptr<Capturer::CaptureData> capture_data) {
+    scoped_refptr<CaptureData> capture_data) {
   DCHECK_EQ(encode_loop_, MessageLoop::current());
 
   // TODO(hclam): Enable |force_refresh| if a new client was
   // added.
   encoder_->Encode(capture_data, false,
                    NewCallback(this, &SessionManager::EncodeDataAvailableTask));
 }
 
 void SessionManager::EncodeDataAvailableTask(
     HostMessage* message, Encoder::EncodingState state) {
   DCHECK_EQ(encode_loop_, MessageLoop::current());
 
   // Before a new encode task starts, notify clients a new update
   // stream is coming.
   // Notify this will keep a reference to the DataBuffer in the
   // task. The ownership will eventually pass to the ClientConnections.
   network_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &SessionManager::DoSendUpdate, message, state));
 
   if (state & Encoder::EncodingEnded) {
     capture_loop_->PostTask(
         FROM_HERE, NewRunnableMethod(this, &SessionManager::DoFinishEncode));
   }
 }
 
 }  // namespace remoting