[CRD iOS] Refactor an interface for RemotingAuthorization

remoting/ios/facade/remoting_service.mm

 // Copyright 2017 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.
 
 #if !defined(__has_feature) || !__has_feature(objc_arc)
 #error "This file requires ARC support."
 #endif
 
 #import "remoting/ios/facade/remoting_service.h"
 
 #import <Foundation/Foundation.h>
 #import <Security/Security.h>
 
 #import "base/mac/bind_objc_block.h"
 #import "remoting/ios/domain/host_info.h"
 #import "remoting/ios/domain/user_info.h"
 #import "remoting/ios/facade/host_info.h"
 #import "remoting/ios/facade/host_list_fetcher.h"
 #import "remoting/ios/facade/ios_client_runtime_delegate.h"
 #import "remoting/ios/facade/remoting_authentication.h"
-#import "remoting/ios/facade/remoting_service.h"
 #import "remoting/ios/keychain_wrapper.h"
 
 #include "base/i18n/time_formatting.h"
 #include "base/logging.h"
 #include "base/strings/sys_string_conversions.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "remoting/base/oauth_token_getter.h"
 #include "remoting/base/oauth_token_getter_impl.h"
 
 static NSString* const kCRDAuthenticatedUserEmailKey =
     @"kCRDAuthenticatedUserEmailKey";
 
 NSString* const kHostsDidUpdate = @"kHostsDidUpdate";
 
 NSString* const kUserDidUpdate = @"kUserDidUpdate";
 NSString* const kUserInfo = @"kUserInfo";
 
 @interface RemotingService ()<RemotingAuthenticationDelegate> {
-  std::unique_ptr<remoting::OAuthTokenGetter> _tokenGetter;
+  id<RemotingAuthentication> _authentication;
   remoting::HostListFetcher* _hostListFetcher;
   remoting::IosClientRuntimeDelegate* _clientRuntimeDelegate;
+  BOOL _isHostListFetching;
 }
 @end
 
 @implementation RemotingService
 
-@synthesize authentication = _authentication;
 @synthesize hosts = _hosts;
 
 // RemotingService is a singleton.
-+ (RemotingService*)SharedInstance {
++ (RemotingService*)instance {
   static RemotingService* sharedInstance = nil;
   static dispatch_once_t guard;
   dispatch_once(&guard, ^{
     sharedInstance = [[RemotingService alloc] init];
   });
   return sharedInstance;
 }
 
 - (instancetype)init {
   self = [super init];
   if (self) {
-    _authentication = [[RemotingAuthentication alloc] init];
-    _authentication.delegate = self;
     _hosts = nil;
     _hostListFetcher = nil;
+    // TODO(yuweih): Maybe better to just cancel the previous request.
+    _isHostListFetching = NO;
     // TODO(nicholss): This might need a pointer back to the service.
     _clientRuntimeDelegate =
         new remoting::IosClientRuntimeDelegate();
     [self runtime]->SetDelegate(_clientRuntimeDelegate);
   }
   return self;
 }
 
 #pragma mark - RemotingService Implementation
 
 - (void)startHostListFetchWith:(NSString*)accessToken {
+  if (_isHostListFetching) {
+    return;
+  }
+  _isHostListFetching = YES;
   if (!_hostListFetcher) {
     _hostListFetcher = new remoting::HostListFetcher(
         remoting::ChromotingClientRuntime::GetInstance()->url_requester());
   }
   _hostListFetcher->RetrieveHostlist(
       base::SysNSStringToUTF8(accessToken),
       base::BindBlockArc(^(const std::vector<remoting::HostInfo>& hostlist) {
         NSMutableArray<HostInfo*>* hosts =
             [NSMutableArray arrayWithCapacity:hostlist.size()];
         std::string status;
@@ skipping 20 matching lines @@
           host.hostVersion = base::SysUTF8ToNSString(host_info.host_version);
           host.jabberId = base::SysUTF8ToNSString(host_info.host_jid);
           host.publicKey = base::SysUTF8ToNSString(host_info.public_key);
           host.status = base::SysUTF8ToNSString(status);
           host.updatedTime = base::SysUTF16ToNSString(
               base::TimeFormatShortDateAndTime(host_info.updated_time));
           [hosts addObject:host];
         }
         _hosts = hosts;
         [self hostListUpdated];
+        _isHostListFetching = NO;
       }));
 }
 
 #pragma mark - Notifications
 
 - (void)hostListUpdated {
   [[NSNotificationCenter defaultCenter] postNotificationName:kHostsDidUpdate
                                                       object:self
                                                     userInfo:nil];
 }
 
 #pragma mark - RemotingAuthenticationDelegate
 
 - (void)userDidUpdate:(UserInfo*)user {
   NSDictionary* userInfo = nil;
   if (user) {
     userInfo = [NSDictionary dictionaryWithObject:user forKey:kUserInfo];
+    [self requestHostListFetch];
   } else {
     _hosts = nil;
     [self hostListUpdated];
   }
   [[NSNotificationCenter defaultCenter] postNotificationName:kUserDidUpdate
                                                       object:self
                                                     userInfo:userInfo];
 }
 
 #pragma mark - Properties
 
 - (NSArray<HostInfo*>*)hosts {
   if ([_authentication.user isAuthenticated]) {
     return _hosts;
   }
   return nil;
 }
 
 - (remoting::ChromotingClientRuntime*)runtime {
   return remoting::ChromotingClientRuntime::GetInstance();
 }
 
 #pragma mark - Implementation
 
 - (void)requestHostListFetch {
   [_authentication
-      callbackWithAccessToken:base::BindBlockArc(^(
-                                  remoting::OAuthTokenGetter::Status status,
-                                  const std::string& user_email,
-                                  const std::string& access_token) {
-        NSString* accessToken = base::SysUTF8ToNSString(access_token);
+      callbackWithAccessToken:^(RemotingAuthenticationStatus status,
+                                NSString* userEmail, NSString* accessToken) {
         [self startHostListFetchWith:accessToken];
-      })];
+      }];
+}
+
+- (void)setAuthentication:(id<RemotingAuthentication>)authentication {
+  DCHECK(_authentication == nil);
+  authentication.delegate = self;
+  _authentication = authentication;
+}
+
+- (id<RemotingAuthentication>)authentication {
+  DCHECK(_authentication != nil);
+  return _authentication;
 }
 
 @end