Changed several references from "char" to "uint8" which is the appropriate de...

chrome/renderer/media/data_source_impl.cc

 // Copyright (c) 2009 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/compiler_specific.h"
 #include "base/message_loop.h"
 #include "chrome/renderer/media/data_source_impl.h"
 #include "chrome/renderer/render_view.h"
 #include "chrome/renderer/webmediaplayer_delegate_impl.h"
 #include "media/base/filter_host.h"
@@ skipping 27 matching lines @@
   stopped_ = true;
 
   // TODO(hclam): things to do here:
   // 1. Call to RenderView to cancel the streaming resource request.
   // 2. Signal download_event_.
   download_event_.Signal();
 
   // Post a close file stream task to IO message loop, it will signal the read
   // event.
   io_loop_->PostTask(
-      FROM_HERE,NewRunnableMethod(this, &DataSourceImpl::OnCloseFileStream));
+      FROM_HERE, NewRunnableMethod(this, &DataSourceImpl::OnCloseFileStream));
 
   // Wait for close to finish for FileStream.
   close_event_.Wait();
 
   // Make sure that when we wake up the stream is closed and destroyed.
   DCHECK(stream_.get() == NULL);
 }
 
 bool DataSourceImpl::Initialize(const std::string& url) {
   // TODO(hclam): call to RenderView by delegate_->view() to initiate a
   // streaming session in the browser process. Call to RenderView by
   // delegate_->view() to initiate a streaming session in the browser process.
   // We should get a call back at OnReceivedResponse().
   media_format_.SetAsString(media::MediaFormat::kMimeType,
                             media::mime_type::kApplicationOctetStream);
-  media_format_.SetAsString(media::MediaFormat::kURL, url); 
+  media_format_.SetAsString(media::MediaFormat::kURL, url);
   return true;
 }
 
-size_t DataSourceImpl::Read(char* data, size_t size) {
+size_t DataSourceImpl::Read(uint8* data, size_t size) {
   DCHECK(stream_.get());
   // Wait until we have downloaded the requested bytes.
-  while(!stopped_) {
+  while (!stopped_) {
     {
       AutoLock auto_lock(lock_);
       if (position_ + size <= downloaded_bytes_)
         break;
     }
     download_event_.Wait();
   }
 
   last_read_size_ = media::DataSource::kReadError;
   if (!stopped_) {
@@ skipping 10 matching lines @@
 }
 
 bool DataSourceImpl::GetPosition(int64* position_out) {
   AutoLock auto_lock(lock_);
   *position_out = position_;
   return true;
 }
 
 bool DataSourceImpl::SetPosition(int64 position) {
   DCHECK(stream_.get());
-  while(!stopped_) {
+  while (!stopped_) {
     {
       AutoLock auto_lock(lock_);
       if (position < downloaded_bytes_)
         break;
     }
     download_event_.Wait();
   }
   if (!stopped_) {
     if (logging::DEBUG_MODE) {
       AutoLock auto_lock_(lock_);
@@ skipping 22 matching lines @@
 }
 
 void DataSourceImpl::OnCreateFileStream(base::PlatformFile file) {
   stream_.reset(
       new net::FileStream(
           file, base::PLATFORM_FILE_READ | base::PLATFORM_FILE_ASYNC));
   // TODO(hclam): maybe we should check the validity of the file handle.
   host_->InitializationComplete();
 }
 
-void DataSourceImpl::OnReadFileStream(char* data, size_t size) {
+void DataSourceImpl::OnReadFileStream(uint8* data, size_t size) {
   if (!stopped_ && stream_.get()) {
+    // net::FileStream::Read wants a char*, not uint8*.
+    char* c_data = reinterpret_cast<char*>(data);
+    COMPILE_ASSERT(sizeof(*c_data) == sizeof(*data), data_not_sizeof_char);
+
     // This method IO operation is asynchronous, it is expected to return
     // ERROR_IO_PENDING, when the operation is done, OnDidFileStreamRead() will
-    // be called.
-    int rv = stream_->Read(data, size, &read_callback_);
-
-    // Since the file handle is asynchronous, return value other than
-    // ERROR_IO_PENDING is an error.
-    if (rv != net::ERR_IO_PENDING) {
-      // TODO(hclam): using something like PipelineError::PIPELINE_READ_ERROR.
+    // be called.  Since the file handle is asynchronous, return value other
+    // than ERROR_IO_PENDING is an error.
+    if (stream_->Read(c_data, size, &read_callback_) != net::ERR_IO_PENDING) {
+      // TODO(hclam): change to PipelineError::PIPELINE_ERROR_READ once ralphl
+      // gets the new pipeline CL checked in.
       host_->Error(media::PIPELINE_ERROR_NETWORK);
     }
   }
 }
 
 void DataSourceImpl::OnCloseFileStream() {
   if (stream_.get()) {
     stream_->Close();
     stream_.reset();
   }
@@ skipping 53 matching lines @@
     downloaded_bytes_ += bytes;
     if (!total_bytes_known_)
       total_bytes_ += bytes;
   }
   download_event_.Signal();
 }
 
 const media::MediaFormat* DataSourceImpl::GetMediaFormat() {
   return &media_format_;
 }