Added support for animated/nonanimated user image.

chrome/browser/ui/webui/chrome_url_data_manager_backend.cc

 // Copyright (c) 2012 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 "chrome/browser/ui/webui/chrome_url_data_manager_backend.h"
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/ui/webui/shared_resources_data_source.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
@@ skipping 137 matching lines @@
 
   // net::URLRequestJob implementation.
   virtual void Start() OVERRIDE;
   virtual void Kill() OVERRIDE;
   virtual bool ReadRawData(net::IOBuffer* buf,
                            int buf_size,
                            int* bytes_read) OVERRIDE;
   virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
   virtual void GetResponseInfo(net::HttpResponseInfo* info) OVERRIDE;
 
+  // Used to notify that the requested data's |mime_type| is ready.
+  void MimeTypeAvailable(const std::string& mime_type);
+
   // Called by ChromeURLDataManager to notify us that the data blob is ready
   // for us.
   void DataAvailable(base::RefCountedMemory* bytes);
 
   void set_mime_type(const std::string& mime_type) {
     mime_type_ = mime_type;
   }
 
   void set_allow_caching(bool allow_caching) {
     allow_caching_ = allow_caching;
@@ skipping 73 matching lines @@
   DCHECK(!info->headers);
   // Set the headers so that requests serviced by ChromeURLDataManager return a
   // status code of 200. Without this they return a 0, which makes the status
   // indistiguishable from other error types. Instant relies on getting a 200.
   info->headers = new net::HttpResponseHeaders("HTTP/1.1 200 OK");
   AddContentSecurityPolicyHeader(request_->url(), info->headers);
   if (!allow_caching_)
     info->headers->AddHeader("Cache-Control: no-cache");
 }
 
+void URLRequestChromeJob::MimeTypeAvailable(const std::string& mime_type) {
+  set_mime_type(mime_type);
+  NotifyHeadersComplete();
+}
+
 void URLRequestChromeJob::DataAvailable(base::RefCountedMemory* bytes) {
   TRACE_EVENT_ASYNC_END0("browser", "DataManager:Request", this);
   if (bytes) {
     // The request completed, and we have all the data.
     // Clear any IO pending status.
     SetStatus(net::URLRequestStatus());
 
     data_ = bytes;
     int bytes_read;
     if (pending_buf_.get()) {
@@ skipping 34 matching lines @@
     memcpy(buf->data(), data_->front() + data_offset_, buf_size);
     data_offset_ += buf_size;
   }
   *bytes_read = buf_size;
 }
 
 void URLRequestChromeJob::StartAsync() {
   if (!request_)
     return;
 
-  if (backend_->StartRequest(request_->url(), this)) {
-    NotifyHeadersComplete();
-  } else {
+  if (!backend_->StartRequest(request_->url(), this)) {
     NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
                                            net::ERR_INVALID_URL));
   }
 }
 
 namespace {
 
+// Gets mime type for data that is available from |source| by |path|.
+// After that, notifies |job| that mime type is available. This method
+// should be called on the UI thread, but notification is performed on
+// the IO thread.
+void GetMimeTypeOnUI(ChromeURLDataManager::DataSource* source,
+                     const std::string& path,
+                     URLRequestChromeJob* job) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  std::string mime_type = source->GetMimeType(path);
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&URLRequestChromeJob::MimeTypeAvailable, job, mime_type));
+}
+
+}  // namespace
+
+namespace {
+
 class ChromeProtocolHandler
     : public net::URLRequestJobFactory::ProtocolHandler {
  public:
   explicit ChromeProtocolHandler(ChromeURLDataManagerBackend* backend);
   ~ChromeProtocolHandler();
 
   virtual net::URLRequestJob* MaybeCreateJob(
       net::URLRequest* request) const OVERRIDE;
 
  private:
@@ skipping 74 matching lines @@
   DataSourceMap::iterator i = data_sources_.find(source_name);
   if (i == data_sources_.end())
     return false;
 
   ChromeURLDataManager::DataSource* source = i->second;
 
   // Save this request so we know where to send the data.
   RequestID request_id = next_request_id_++;
   pending_requests_.insert(std::make_pair(request_id, job));
 
-  // TODO(eroman): would be nicer if the mimetype were set at the same time
-  // as the data blob. For now do it here, since NotifyHeadersComplete() is
-  // going to get called once we return.
-  job->set_mime_type(source->GetMimeType(path));
   job->set_allow_caching(source->AllowCaching());
 
   const ChromeURLRequestContext* context =
       static_cast<const ChromeURLRequestContext*>(job->request()->context());
 
   // Forward along the request to the data source.
   MessageLoop* target_message_loop = source->MessageLoopForRequestPath(path);
   if (!target_message_loop) {
+    job->MimeTypeAvailable(source->GetMimeType(path));
+
     // The DataSource is agnostic to which thread StartDataRequest is called
     // on for this path.  Call directly into it from this thread, the IO
     // thread.
     source->StartDataRequest(path, context->is_incognito(), request_id);
   } else {
+    // URLRequestChromeJob should receive mime type before data. This
+    // is guaranteed because request for mime type is placed in the
+    // message loop before request for data. And correspondingly their
+    // replies are put on the IO thread in the same order.
+    target_message_loop->PostTask(
+        FROM_HERE,
+        base::Bind(&GetMimeTypeOnUI,
+                   scoped_refptr<ChromeURLDataManager::DataSource>(source),
+                   path,
+                   scoped_refptr<URLRequestChromeJob>(job)));
+
     // The DataSource wants StartDataRequest to be called on a specific thread,
     // usually the UI thread, for this path.
     target_message_loop->PostTask(
         FROM_HERE,
         base::Bind(&ChromeURLDataManager::DataSource::StartDataRequest, source,
                    path, context->is_incognito(), request_id));
   }
   return true;
 }
 
@@ skipping 112 matching lines @@
 
   return new URLRequestChromeJob(request, backend_);
 }
 
 }  // namespace
 
 net::URLRequestJobFactory::ProtocolHandler*
 CreateDevToolsProtocolHandler(ChromeURLDataManagerBackend* backend) {
   return new DevToolsJobFactory(backend);
 }