Implement NetworkFetcher interface for Mac.

Bug: 1020650

Change-Id: I8da0968e81d86646f62fda300bb783142a4d6236
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1898613
Commit-Queue: Mila Green <milagreen@chromium.org>
Reviewed-by: Joshua Pawlicki <waffles@chromium.org>
Reviewed-by: Elly Fong-Jones <ellyjones@chromium.org>
Reviewed-by: Sorin Jianu <sorin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#714251}

chrome/updater/BUILD.gn

@@ -101,6 +101,8 @@ if (is_win || is_mac) {
     }
 
     if (is_mac) {
+      deps += [ "//chrome/updater/mac:updater_tests" ]
+
       data_deps = [
         "//chrome/updater/mac:updater",
       ]

chrome/updater/mac/BUILD.gn

@@ -14,6 +14,37 @@ executable("updater") {
   ]
 
   deps = [
+    ":network_fetcher_sources",
     "//chrome/updater:common",
   ]
 }
+
+source_set("network_fetcher_sources") {
+  sources = [
+    "net/network.h",
+    "net/network_fetcher.h",
+    "net/network_fetcher.mm",
+  ]
+
+  deps = [
+    "//base",
+    "//components/update_client",
+    "//net",
+  ]
+}
+
+source_set("updater_tests") {
+  testonly = true
+
+  sources = [
+    "net/network_unittest.mm",
+  ]
+
+  deps = [
+    ":network_fetcher_sources",
+    "//base/test:test_support",
+    "//net:test_support",
+    "//testing/gmock",
+    "//testing/gtest",
+  ]
+}

chrome/updater/mac/net/network.h

+// Copyright 2019 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.
+
+#ifndef CHROME_UPDATER_MAC_NET_NETWORK_H_
+#define CHROME_UPDATER_MAC_NET_NETWORK_H_
+
+#include <memory>
+
+#include "base/macros.h"
+#include "base/threading/thread_checker.h"
+#include "components/update_client/network.h"
+
+namespace updater {
+
+class NetworkFetcherFactory : public update_client::NetworkFetcherFactory {
+ public:
+  NetworkFetcherFactory();
+
+  std::unique_ptr<update_client::NetworkFetcher> Create() const override;
+
+ protected:
+  ~NetworkFetcherFactory() override;
+
+ private:
+  THREAD_CHECKER(thread_checker_);
+
+  DISALLOW_COPY_AND_ASSIGN(NetworkFetcherFactory);
+};
+
+}  // namespace updater
+
+#endif  // CHROME_UPDATER_MAC_NET_NETWORK_H_

chrome/updater/mac/net/network_fetcher.h

+// Copyright 2019 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.
+
+#ifndef CHROME_UPDATER_MAC_NET_NETWORK_FETCHER_H_
+#define CHROME_UPDATER_MAC_NET_NETWORK_FETCHER_H_
+
+#include <stdint.h>
+
+#include <string>
+
+#include "base/callback.h"
+#include "base/containers/flat_map.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/threading/thread_checker.h"
+#include "components/update_client/network.h"
+
+class GURL;
+
+namespace base {
+class FilePath;
+}  // namespace base
+
+namespace updater {
+
+class NetworkFetcher : public update_client::NetworkFetcher {
+ public:
+  NetworkFetcher();
+  NetworkFetcher& operator=(const NetworkFetcher&) = delete;
+  NetworkFetcher(const NetworkFetcher&) = delete;
+  ~NetworkFetcher() override;
+
+  // NetworkFetcher overrides.
+  void PostRequest(
+      const GURL& url,
+      const std::string& post_data,
+      const base::flat_map<std::string, std::string>& post_additional_headers,
+      update_client::NetworkFetcher::ResponseStartedCallback
+          response_started_callback,
+      update_client::NetworkFetcher::ProgressCallback progress_callback,
+      update_client::NetworkFetcher::PostRequestCompleteCallback
+          post_request_complete_callback) override;
+
+  void DownloadToFile(
+      const GURL& url,
+      const base::FilePath& file_path,
+      update_client::NetworkFetcher::ResponseStartedCallback
+          response_started_callback,
+      update_client::NetworkFetcher::ProgressCallback progress_callback,
+      update_client::NetworkFetcher::DownloadToFileCompleteCallback
+          download_to_file_complete_callback) override;
+
+ private:
+  THREAD_CHECKER(thread_checker_);
+};
+
+}  // namespace updater
+
+#endif  // CHROME_UPDATER_MAC_NET_NETWORK_FETCHER_H_

chrome/updater/mac/net/network_fetcher.mm

+// Copyright 2019 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/updater/mac/net/network_fetcher.h"
+
+#import <Foundation/Foundation.h>
+#include <memory>
+#include <utility>
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/callback_helpers.h"
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#import "base/mac/foundation_util.h"
+#import "base/mac/scoped_nsobject.h"
+#include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
+#include "base/strings/sys_string_conversions.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "chrome/updater/mac/net/network.h"
+#import "net/base/mac/url_conversions.h"
+#include "url/gurl.h"
+
+const NSString* kHeaderEtag = @"ETag";
+const NSString* kHeaderXRetryAfter = @"X-Retry-After";
+
+using ResponseStartedCallback =
+    update_client::NetworkFetcher::ResponseStartedCallback;
+using ProgressCallback = update_client::NetworkFetcher::ProgressCallback;
+using PostRequestCompleteCallback =
+    update_client::NetworkFetcher::PostRequestCompleteCallback;
+using DownloadToFileCompleteCallback =
+    update_client::NetworkFetcher::DownloadToFileCompleteCallback;
+
+@interface CHUpdaterNetworkController : NSObject <NSURLSessionDelegate>
+- (instancetype)initWithResponseStartedCallback:
+                    (ResponseStartedCallback)responseStartedCallback
+                               progressCallback:
+                                   (ProgressCallback)progressCallback;
+@end
+
+@implementation CHUpdaterNetworkController {
+ @protected
+  ResponseStartedCallback responseStartedCallback_;
+  ProgressCallback progressCallback_;
+}
+
+- (instancetype)initWithResponseStartedCallback:
+                    (ResponseStartedCallback)responseStartedCallback
+                               progressCallback:
+                                   (ProgressCallback)progressCallback {
+  if (self == [super init]) {
+    responseStartedCallback_ = std::move(responseStartedCallback);
+    progressCallback_ = progressCallback;
+  }
+  return self;
+}
+
+#pragma mark - NSURLSessionDelegate
+
+- (void)URLSession:(NSURLSession*)session
+                    task:(NSURLSessionTask*)task
+    didCompleteWithError:(NSError*)error {
+  if (error) {
+    DLOG(ERROR) << "NSURLSession error: " << error
+                << ". NSURLSession: " << session
+                << ". NSURLSessionTask: " << task;
+  }
+}
+@end
+
+@interface CHUpdaterNetworkDataDelegate
+    : CHUpdaterNetworkController <NSURLSessionDataDelegate>
+- (instancetype)
+    initWithResponseStartedCallback:
+        (ResponseStartedCallback)responseStartedCallback
+                   progressCallback:(ProgressCallback)progressCallback
+        postRequestCompleteCallback:
+            (PostRequestCompleteCallback)postRequestCompleteCallback;
+@end
+
+@implementation CHUpdaterNetworkDataDelegate {
+  PostRequestCompleteCallback postRequestCompleteCallback_;
+  base::scoped_nsobject<NSMutableData> downloadedData_;
+}
+
+- (instancetype)
+    initWithResponseStartedCallback:
+        (ResponseStartedCallback)responseStartedCallback
+                   progressCallback:(ProgressCallback)progressCallback
+        postRequestCompleteCallback:
+            (PostRequestCompleteCallback)postRequestCompleteCallback {
+  if (self ==
+      [super initWithResponseStartedCallback:std::move(responseStartedCallback)
+                            progressCallback:progressCallback]) {
+    postRequestCompleteCallback_ = std::move(postRequestCompleteCallback);
+  }
+  return self;
+}
+
+#pragma mark - NSURLSessionDataDelegate
+
+- (void)URLSession:(NSURLSession*)session
+          dataTask:(NSURLSessionDataTask*)dataTask
+    didReceiveData:(NSData*)data {
+  if (downloadedData_ == nil) {
+    downloadedData_.reset([[NSMutableData alloc] init]);
+  }
+  [downloadedData_ appendData:data];
+
+  int64_t current = 0;
+
+  if (dataTask.countOfBytesExpectedToReceive > 0) {
+    current = (dataTask.countOfBytesReceived * 100) /
+              dataTask.countOfBytesExpectedToReceive;
+  } else {
+    current = 100;
+  }
+  progressCallback_.Run(current);
+  [dataTask resume];
+}
+
+// Tells the delegate that the data task received the initial reply (headers)
+// from the server.
+- (void)URLSession:(NSURLSession*)session
+              dataTask:(NSURLSessionDataTask*)dataTask
+    didReceiveResponse:(NSURLResponse*)response
+     completionHandler:
+         (void (^)(NSURLSessionResponseDisposition))completionHandler {
+  std::move(responseStartedCallback_)
+      .Run([(NSHTTPURLResponse*)response statusCode],
+           dataTask.countOfBytesExpectedToReceive);
+  if (completionHandler) {
+    completionHandler(NSURLSessionResponseAllow);
+  }
+  [dataTask resume];
+}
+
+#pragma mark - NSURLSessionDelegate
+
+- (void)URLSession:(NSURLSession*)session
+                    task:(NSURLSessionTask*)task
+    didCompleteWithError:(NSError*)error {
+  [super URLSession:session task:task didCompleteWithError:error];
+
+  NSHTTPURLResponse* response = (NSHTTPURLResponse*)task.response;
+  NSDictionary* headers = response.allHeaderFields;
+  NSString* etag = @"";
+  if ([headers objectForKey:kHeaderEtag]) {
+    etag = [headers objectForKey:kHeaderEtag];
+  }
+  int64_t retryAfterResult = -1;
+  NSString* xRetryAfter = [headers objectForKey:kHeaderXRetryAfter];
+  if (xRetryAfter) {
+    retryAfterResult = [xRetryAfter intValue];
+  }
+
+  std::move(postRequestCompleteCallback_)
+      .Run(std::make_unique<std::string>(
+               base::SysNSStringToUTF8(response.description)),
+           response.statusCode, std::string(base::SysNSStringToUTF8(etag)),
+           retryAfterResult);
+}
+
+@end
+
+@interface CHUpdaterNetworkDownloadDelegate
+    : CHUpdaterNetworkController <NSURLSessionDownloadDelegate>
+- (instancetype)
+    initWithResponseStartedCallback:
+        (ResponseStartedCallback)responseStartedCallback
+                   progressCallback:(ProgressCallback)progressCallback
+                           filePath:(const base::FilePath&)filePath
+     downloadToFileCompleteCallback:
+         (DownloadToFileCompleteCallback)downloadToFileCompleteCallback;
+@end
+
+@implementation CHUpdaterNetworkDownloadDelegate {
+  base::FilePath filePath_;
+  DownloadToFileCompleteCallback downloadToFileCompleteCallback_;
+}
+
+- (instancetype)
+    initWithResponseStartedCallback:
+        (ResponseStartedCallback)responseStartedCallback
+                   progressCallback:(ProgressCallback)progressCallback
+                           filePath:(const base::FilePath&)filePath
+     downloadToFileCompleteCallback:
+         (DownloadToFileCompleteCallback)downloadToFileCompleteCallback {
+  if (self ==
+      [super initWithResponseStartedCallback:std::move(responseStartedCallback)
+                            progressCallback:progressCallback]) {
+    filePath_ = filePath;
+    downloadToFileCompleteCallback_ = std::move(downloadToFileCompleteCallback);
+  }
+  return self;
+}
+
+#pragma mark - NSURLSessionDownloadDelegate
+
+- (void)URLSession:(NSURLSession*)session
+             dataTask:(NSURLSessionDataTask*)dataTask
+    willCacheResponse:(NSCachedURLResponse*)proposedResponse
+    completionHandler:
+        (void (^)(NSCachedURLResponse* _Nullable))completionHandler {
+  completionHandler(NULL);
+}
+
+- (void)URLSession:(NSURLSession*)session
+                 downloadTask:(NSURLSessionDownloadTask*)downloadTask
+    didFinishDownloadingToURL:(NSURL*)location {
+  if (!location)
+    return;
+
+  const base::FilePath tempPath =
+      base::mac::NSStringToFilePath([location path]);
+  base::File::Error fileError;
+  if (!base::ReplaceFile(tempPath, filePath_, &fileError)) {
+    DLOG(ERROR)
+        << "Failed to move the downloaded file from the temporary location: "
+        << tempPath << "to: " << filePath_
+        << " Error: " << base::File::ErrorToString(fileError);
+  }
+}
+
+#pragma mark - NSURLSessionDelegate
+
+- (void)URLSession:(NSURLSession*)session
+                    task:(NSURLSessionTask*)task
+    didCompleteWithError:(NSError*)error {
+  [super URLSession:session task:task didCompleteWithError:error];
+
+  NSHTTPURLResponse* response = (NSHTTPURLResponse*)task.response;
+  NSURL* destination = base::mac::FilePathToNSURL(filePath_);
+  NSString* filePath = [destination path];
+  NSDictionary<NSFileAttributeKey, id>* attributes =
+      [[NSFileManager defaultManager] attributesOfItemAtPath:filePath
+                                                       error:nil];
+  NSNumber* fileSizeAttribute = attributes[NSFileSize];
+  int64_t fileSize = [fileSizeAttribute integerValue];
+  std::move(downloadToFileCompleteCallback_).Run(response.statusCode, fileSize);
+}
+
+@end
+
+namespace base {
+class SingleThreadTaskRunner;
+}
+
+namespace updater {
+
+NetworkFetcher::NetworkFetcher() {}
+
+NetworkFetcher::~NetworkFetcher() {}
+
+void NetworkFetcher::PostRequest(
+    const GURL& url,
+    const std::string& post_data,
+    const base::flat_map<std::string, std::string>& post_additional_headers,
+    ResponseStartedCallback response_started_callback,
+    ProgressCallback progress_callback,
+    PostRequestCompleteCallback post_request_complete_callback) {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+
+  base::scoped_nsobject<CHUpdaterNetworkDataDelegate> delegate(
+      [[CHUpdaterNetworkDataDelegate alloc]
+          initWithResponseStartedCallback:std::move(response_started_callback)
+                         progressCallback:progress_callback
+              postRequestCompleteCallback:std::move(
+                                              post_request_complete_callback)]);
+
+  NSURLSession* session =
+      [NSURLSession sessionWithConfiguration:[NSURLSessionConfiguration
+                                                 defaultSessionConfiguration]
+                                    delegate:delegate
+                               delegateQueue:nil];
+
+  base::scoped_nsobject<NSMutableURLRequest> urlRequest(
+      [[NSMutableURLRequest alloc] initWithURL:net::NSURLWithGURL(url)]);
+  [urlRequest setHTTPMethod:@"POST"];
+  [urlRequest setHTTPBody:[base::SysUTF8ToNSString(post_data)
+                              dataUsingEncoding:NSUTF8StringEncoding]];
+  VLOG(1) << "Posting data: " << post_data.c_str();
+
+  NSURLSessionDataTask* dataTask = [session dataTaskWithRequest:urlRequest];
+  [dataTask resume];
+}
+
+void NetworkFetcher::DownloadToFile(
+    const GURL& url,
+    const base::FilePath& file_path,
+    ResponseStartedCallback response_started_callback,
+    ProgressCallback progress_callback,
+    DownloadToFileCompleteCallback download_to_file_complete_callback) {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+
+  base::scoped_nsobject<CHUpdaterNetworkDownloadDelegate> delegate(
+      [[CHUpdaterNetworkDownloadDelegate alloc]
+          initWithResponseStartedCallback:std::move(response_started_callback)
+                         progressCallback:progress_callback
+                                 filePath:file_path
+           downloadToFileCompleteCallback:
+               std::move(download_to_file_complete_callback)]);
+
+  NSURLSession* session =
+      [NSURLSession sessionWithConfiguration:[NSURLSessionConfiguration
+                                                 defaultSessionConfiguration]
+                                    delegate:delegate
+                               delegateQueue:nil];
+
+  base::scoped_nsobject<NSMutableURLRequest> urlRequest(
+      [[NSMutableURLRequest alloc] initWithURL:net::NSURLWithGURL(url)]);
+
+  NSURLSessionDownloadTask* downloadTask =
+      [session downloadTaskWithRequest:urlRequest];
+  [downloadTask resume];
+}
+
+NetworkFetcherFactory::NetworkFetcherFactory() = default;
+NetworkFetcherFactory::~NetworkFetcherFactory() = default;
+
+std::unique_ptr<update_client::NetworkFetcher> NetworkFetcherFactory::Create()
+    const {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+  return std::make_unique<NetworkFetcher>();
+}
+
+}  // namespace updater

chrome/updater/mac/net/network_unittest.mm

+// Copyright 2019 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/updater/mac/net/network.h"
+#include "chrome/updater/mac/net/network_fetcher.h"
+
+#include <stdint.h>
+
+#include "base/bind.h"
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/files/scoped_temp_dir.h"
+#include "base/memory/ref_counted.h"
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "base/test/task_environment.h"
+#include "net/test/embedded_test_server/embedded_test_server.h"
+#include "net/test/embedded_test_server/http_request.h"
+#include "net/test/embedded_test_server/http_response.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
+
+using ResponseStartedCallback =
+    update_client::NetworkFetcher::ResponseStartedCallback;
+using ProgressCallback = update_client::NetworkFetcher::ProgressCallback;
+using PostRequestCompleteCallback =
+    update_client::NetworkFetcher::PostRequestCompleteCallback;
+using DownloadToFileCompleteCallback =
+    update_client::NetworkFetcher::DownloadToFileCompleteCallback;
+
+namespace updater {
+ACTION_P(RunClosure, closure) {
+  closure.Run();
+}
+
+static base::FilePath testFilePath;
+
+class ChromeUpdaterNetworkMacTest : public ::testing::Test {
+ public:
+  ~ChromeUpdaterNetworkMacTest() override = default;
+
+#pragma mark - Callback Methods
+  void StartedCallback(int response_code, int64_t content_length) {
+    EXPECT_EQ(response_code, 200);
+  }
+
+  void ProgressCallback(int64_t current) {
+    EXPECT_GE(current, 0);
+    EXPECT_LE(current, 100);
+  }
+
+  void PostRequestCompleteCallback(std::unique_ptr<std::string> response_body,
+                                   int net_error,
+                                   const std::string& header_etag,
+                                   int64_t xheader_retry_after_sec) {
+    EXPECT_EQ(net_error, 200);
+    EXPECT_GT(header_etag.length(), 0u);
+    EXPECT_EQ(xheader_retry_after_sec, 67);
+    PostRequestCompleted();
+  }
+
+  void DownloadCallback(int net_error, int64_t content_size) {
+    EXPECT_EQ(net_error, 200);
+    EXPECT_GT(content_size, 0);
+    ASSERT_FALSE(testFilePath.empty());
+    ASSERT_TRUE(base::PathExists(testFilePath));
+    ASSERT_TRUE(base::DeleteFile(testFilePath, false));
+    DownloadToFileCompleted();
+  }
+
+  std::unique_ptr<net::test_server::HttpResponse> HandleRequest(
+      const net::test_server::HttpRequest& request) {
+    auto http_response =
+        std::make_unique<net::test_server::BasicHttpResponse>();
+    http_response->set_code(net::HTTP_OK);
+    http_response->set_content("hello");
+    http_response->set_content_type("text/plain");
+    http_response->AddCustomHeader("X-Retry-After", "67");
+    http_response->AddCustomHeader("ETag", "Wfhw789h");
+    return http_response;
+  }
+
+  MOCK_METHOD0(DownloadToFileCompleted, void(void));
+  MOCK_METHOD0(PostRequestCompleted, void(void));
+
+  base::test::SingleThreadTaskEnvironment task_environment_;
+};
+
+#pragma mark - Test Methods
+TEST_F(ChromeUpdaterNetworkMacTest, NetworkFetcherMacHTTPFactory) {
+  base::RunLoop run_loop;
+  base::RepeatingClosure quit_closure = run_loop.QuitClosure();
+  auto fetcher = base::MakeRefCounted<NetworkFetcherFactory>()->Create();
+  quit_closure.Run();
+  run_loop.Run();
+  EXPECT_NE(nullptr, fetcher.get());
+}
+
+TEST_F(ChromeUpdaterNetworkMacTest, NetworkFetcherMacPostRequest) {
+  base::RunLoop run_loop;
+  base::RepeatingClosure quit_closure = run_loop.QuitClosure();
+  EXPECT_CALL(*this, PostRequestCompleted()).WillOnce(RunClosure(quit_closure));
+
+  auto fetcher = base::MakeRefCounted<NetworkFetcherFactory>()->Create();
+
+  net::EmbeddedTestServer test_server;
+  test_server.RegisterRequestHandler(base::Bind(
+      &ChromeUpdaterNetworkMacTest::HandleRequest, base::Unretained(this)));
+  ASSERT_TRUE(test_server.Start());
+  const GURL url = test_server.GetURL("/echo");
+
+  fetcher->PostRequest(
+      url, "", {},
+      base::BindOnce(&ChromeUpdaterNetworkMacTest::StartedCallback,
+                     base::Unretained(this)),
+      base::BindRepeating(&ChromeUpdaterNetworkMacTest::ProgressCallback,
+                          base::Unretained(this)),
+      base::BindOnce(&ChromeUpdaterNetworkMacTest::PostRequestCompleteCallback,
+                     base::Unretained(this)));
+
+  run_loop.Run();
+}
+
+TEST_F(ChromeUpdaterNetworkMacTest, NetworkFetcherMacDownloadToFile) {
+  base::RunLoop run_loop;
+  base::RepeatingClosure quit_closure = run_loop.QuitClosure();
+  EXPECT_CALL(*this, DownloadToFileCompleted())
+      .WillOnce(RunClosure(quit_closure));
+  auto fetcher = base::MakeRefCounted<NetworkFetcherFactory>()->Create();
+
+  net::EmbeddedTestServer test_server;
+  test_server.RegisterRequestHandler(base::Bind(
+      &ChromeUpdaterNetworkMacTest::HandleRequest, base::Unretained(this)));
+  ASSERT_TRUE(test_server.Start());
+  const GURL url = test_server.GetURL("/echo");
+
+  base::ScopedTempDir temp_dir;
+  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+  testFilePath = temp_dir.GetPath().Append(FILE_PATH_LITERAL("from_file"));
+
+  fetcher->DownloadToFile(
+      url, testFilePath,
+      base::BindOnce(&ChromeUpdaterNetworkMacTest::StartedCallback,
+                     base::Unretained(this)),
+      base::BindRepeating(&ChromeUpdaterNetworkMacTest::ProgressCallback,
+                          base::Unretained(this)),
+      base::BindOnce(&ChromeUpdaterNetworkMacTest::DownloadCallback,
+                     base::Unretained(this)));
+
+  run_loop.Run();
+}
+}  // namespace updater