Support content scheme uri for Chrome on Android

net/url_request/url_request_file_job_unittest.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 "net/url_request/url_request_file_job.h"
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "net/base/filename_util.h"
 #include "net/base/net_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#if defined(OS_ANDROID)
+#include "base/test/test_file_util.h"
+#endif
+
 namespace net {
 
 namespace {
 
 // A URLRequestFileJob for testing OnSeekComplete / OnReadComplete callbacks.
 class URLRequestFileJobWithCallbacks : public URLRequestFileJob {
  public:
   URLRequestFileJobWithCallbacks(
       URLRequest* request,
       NetworkDelegate* network_delegate,
@@ skipping 60 matching lines @@
     return nullptr;
   }
 
   net::URLRequestJob* MaybeInterceptResponse(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const override {
     return nullptr;
   }
 
   bool IsHandledProtocol(const std::string& scheme) const override {
+#if defined(OS_ANDROID)
+    return scheme == "file" || scheme == "content";
+#endif
     return scheme == "file";
   }
 
   bool IsHandledURL(const GURL& url) const override {
     return IsHandledProtocol(url.scheme());
   }
 
   bool IsSafeRedirectTarget(const GURL& location) const override {
     return false;
   }
@@ skipping 56 matching lines @@
 
  protected:
   // This creates a file with |content| as the contents, and then creates and
   // runs a URLRequestFileJobWithCallbacks job to get the contents out of it,
   // and makes sure that the callbacks observed the correct bytes. If a Range
   // is provided, this function will add the appropriate Range http header to
   // the request and verify that only the bytes in that range (inclusive) were
   // observed.
   void RunRequest(const std::string& content, const Range* range);
 
+
+  // Helper methods called by RunRequest to run the url request and verify
+  // the returned results.
+  void RunRequestInternal(const base::FilePath& path,
+                          const Range* range);
+  void VerifyResult(const std::string& content,
+                    const Range* range);
+
   JobObserverImpl observer_;
   TestURLRequestContext context_;
   TestDelegate delegate_;
 };
 
 URLRequestFileJobEventsTest::URLRequestFileJobEventsTest() {}
 
 void URLRequestFileJobEventsTest::RunRequest(const std::string& content,
                                              const Range* range) {
   base::ScopedTempDir directory;
   ASSERT_TRUE(directory.CreateUniqueTempDir());
   base::FilePath path;
   ASSERT_TRUE(CreateTempFileWithContent(content, directory, &path));
+  if (range)
+    ASSERT_LT(static_cast<unsigned int>(range->end), content.length());

[asanka, 2014/11/21 02:22:02]

Why not test the behavior when a range request extends past the end of the
content length?

+  RunRequestInternal(path, range);
+  VerifyResult(content, range);
+}
+
+void URLRequestFileJobEventsTest::RunRequestInternal(
+    const base::FilePath& path,
+    const Range* range) {
   CallbacksJobFactory factory(path, &observer_);
   context_.set_job_factory(&factory);
 
   scoped_ptr<URLRequest> request(context_.CreateRequest(
       FilePathToFileURL(path), DEFAULT_PRIORITY, &delegate_, NULL));
   if (range) {
     ASSERT_GE(range->start, 0);
     ASSERT_GE(range->end, 0);
     ASSERT_LE(range->start, range->end);
-    ASSERT_LT(static_cast<unsigned int>(range->end), content.length());
     std::string range_value =
         base::StringPrintf("bytes=%d-%d", range->start, range->end);
     request->SetExtraRequestHeaderByName(
         HttpRequestHeaders::kRange, range_value, true /*overwrite*/);
   }
   request->Start();
 
   base::RunLoop loop;
   loop.Run();
+}
+
+void URLRequestFileJobEventsTest::VerifyResult(const std::string& content,
+                                               const Range* range) {
 

[asanka, 2014/11/21 02:22:02]

extra whitespace.

   EXPECT_FALSE(delegate_.request_failed());
   int expected_length =
       range ? (range->end - range->start + 1) : content.length();
   EXPECT_EQ(delegate_.bytes_received(), expected_length);
 
   std::string expected_content;
   if (range) {
     expected_content.insert(0, content, range->start, expected_length);
   } else {
     expected_content = content;
@@ skipping 39 matching lines @@
 }
 
 TEST_F(URLRequestFileJobEventsTest, Range) {
   // Use a 15KB content file and read a range chosen somewhat arbitrarily but
   // not aligned on any likely page boundaries.
   int size = 15 * 1024;
   Range range(1701, (6 * 1024) + 3);
   RunRequest(MakeContentOfSize(size), &range);
 }
 
+#if defined(OS_ANDROID)
+TEST_F(URLRequestFileJobEventsTest, ContentUriFile) {
+  base::FilePath test_dir;
+  PathService::Get(base::DIR_SOURCE_ROOT, &test_dir);
+  test_dir = test_dir.AppendASCII("net");
+  test_dir = test_dir.AppendASCII("data");
+  test_dir = test_dir.AppendASCII("url_request_unittest");
+  ASSERT_TRUE(base::PathExists(test_dir));
+  base::FilePath image_file = test_dir.Append(FILE_PATH_LITERAL("red.png"));
+
+  // Insert the image into MediaStore. MediaStore will do some conversions, and
+  // return the content URI.
+  base::FilePath path = base::InsertImageIntoMediaStore(image_file);
+  EXPECT_TRUE(path.IsContentUri());
+  EXPECT_TRUE(base::PathExists(path));
+  int64 file_size;
+  EXPECT_TRUE(base::GetFileSize(path, &file_size));
+  EXPECT_LT(0, file_size);
+
+  RunRequestInternal(path, NULL);

[asanka, 2014/11/21 02:22:02]

This doesn't run the test with a content:// URI, does it?

+  EXPECT_FALSE(delegate_.request_failed());
+  EXPECT_EQ(delegate_.bytes_received(), file_size);

[asanka, 2014/11/21 02:22:02]

Assuming the test will still look like this, the received bytes can also be
verified by comparing with the contents of the file.

+}
+#endif
+
 }  // namespace
 
 }  // namespace net