[CRD iOS] Add the host setup instruction page

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"
 
@@ skipping 12 matching lines @@
 #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 kHostListStateDidChange = @"kHostListStateDidChange";
 
 NSString* const kUserDidUpdate = @"kUserDidUpdate";
 NSString* const kUserInfo = @"kUserInfo";
 
 @interface RemotingService ()<RemotingAuthenticationDelegate> {
   id<RemotingAuthentication> _authentication;
   remoting::HostListFetcher* _hostListFetcher;
   remoting::IosClientRuntimeDelegate* _clientRuntimeDelegate;
-  BOOL _isHostListFetching;
 }
 @end
 
 @implementation RemotingService
 
 @synthesize hosts = _hosts;
+@synthesize hostListState = _hostListState;
 
 // RemotingService is a singleton.
 + (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) {
     _hosts = nil;
     _hostListFetcher = nil;
     // TODO(yuweih): Maybe better to just cancel the previous request.
-    _isHostListFetching = NO;
+    _hostListState = HostListStateNotFetched;
     // 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) {
+  if (_hostListState == HostListStateFetching) {
     return;
   }
-  _isHostListFetching = YES;
+  [self setHostListState:HostListStateFetching];
   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 19 matching lines @@
               base::SysUTF8ToNSString(host_info.host_os_version);
           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;
+        [self setHostListState:HostListStateFetched];
       }));
 }
 
-#pragma mark - Notifications
-
-- (void)hostListUpdated {
-  [[NSNotificationCenter defaultCenter] postNotificationName:kHostsDidUpdate
-                                                      object:self
-                                                    userInfo:nil];
+- (void)setHostListState:(HostListState)state {
+  if (state == _hostListState) {
+    return;
+  }
+  _hostListState = state;
+  [[NSNotificationCenter defaultCenter]
+      postNotificationName:kHostListStateDidChange
+                    object:self
+                  userInfo:nil];
 }
 
 #pragma mark - RemotingAuthenticationDelegate
 
 - (void)userDidUpdate:(UserInfo*)user {
   NSDictionary* userInfo = nil;
+  [self setHostListState:HostListStateNotFetched];
   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]) {
@@ skipping 21 matching lines @@
   authentication.delegate = self;
   _authentication = authentication;
 }
 
 - (id<RemotingAuthentication>)authentication {
   DCHECK(_authentication != nil);
   return _authentication;
 }
 
 @end