[ios, osx] Renamed offline classes

Renamed SDK classes related to offline viewing to more closely match the terminology used by mbgl and the Android SDK while remaining consistent with Cocoa naming principles.

12 files changed, 158 insertions, 158 deletions

diff --git a/platform/darwin/include/MGLDownloadController.h b/platform/darwin/include/MGLDownloadController.h
deleted file mode 100644
index 86bd1e6573..0000000000
--- a/platform/darwin/include/MGLDownloadController.h
+++ /dev/null
@@ -1,30 +0,0 @@
-#import <Foundation/Foundation.h>
-
-#import "MGLTypes.h"
-
-NS_ASSUME_NONNULL_BEGIN
-
-@class MGLDownloadable;
-@protocol MGLDownloadRegion;
-
-typedef void (^MGLDownloadableRegistrationCompletionHandler)(MGLDownloadable *downloadable, NSError *error);
-typedef void (^MGLDownloadableRemovalCompletionHandler)(NSError *error);
-typedef void (^MGLDownloadablesRequestCompletionHandler)(NS_ARRAY_OF(MGLDownloadable *) *downloadables, NSError *error);
-
-@interface MGLDownloadController : NSObject
-
-+ (instancetype)sharedController;
-
-- (instancetype)init NS_UNAVAILABLE;
-
-- (void)addDownloadableForRegion:(id <MGLDownloadRegion>)downloadRegion withContext:(NSData *)context completionHandler:(MGLDownloadableRegistrationCompletionHandler)completion;
-
-- (void)removeDownloadable:(MGLDownloadable *)downloadable withCompletionHandler:(MGLDownloadableRemovalCompletionHandler)completion;
-
-- (void)requestDownloadablesWithCompletionHandler:(MGLDownloadablesRequestCompletionHandler)completion;
-
-- (void)setMaximumAllowedMapboxTiles:(uint64_t)maximumCount;
-
-@end
-
-NS_ASSUME_NONNULL_END
diff --git a/platform/darwin/include/MGLDownloadable.h b/platform/darwin/include/MGLDownloadable.h
deleted file mode 100644
index 522a3c37ab..0000000000
--- a/platform/darwin/include/MGLDownloadable.h
+++ /dev/null
@@ -1,49 +0,0 @@
-#import <Foundation/Foundation.h>
-
-#import "MGLDownloadRegion.h"
-
-NS_ASSUME_NONNULL_BEGIN
-
-@protocol MGLDownloadableDelegate;
-
-typedef NS_ENUM (NSInteger, MGLDownloadableState) {
-    MGLDownloadableStateInactive = 0,
-    MGLDownloadableStateActive = 1,
-    MGLDownloadableStateComplete = 2,
-};
-
-typedef struct MGLDownloadableProgress {
-    uint64_t countOfResourcesCompleted;
-    uint64_t countOfBytesCompleted;
-    uint64_t countOfResourcesExpected;
-    uint64_t maximumResourcesExpected;
-} MGLDownloadableProgress;
-
-@interface MGLDownloadable : NSObject
-
-@property (nonatomic, readonly) id <MGLDownloadRegion> region;
-@property (nonatomic, readonly) NSData *context;
-@property (nonatomic, readonly) MGLDownloadableState state;
-@property (nonatomic, readonly) MGLDownloadableProgress progress;
-@property (nonatomic, weak, nullable) id <MGLDownloadableDelegate> delegate;
-
-- (instancetype)init NS_UNAVAILABLE;
-
-- (void)resume;
-- (void)suspend;
-
-- (void)requestProgress;
-
-@end
-
-@protocol MGLDownloadableDelegate <NSObject>
-
-@optional
-
-- (void)downloadable:(MGLDownloadable *)downloadable progressDidChange:(MGLDownloadableProgress)progress;
-- (void)downloadable:(MGLDownloadable *)downloadable didReceiveError:(NSError *)error;
-- (void)downloadable:(MGLDownloadable *)downloadable didReceiveMaximumAllowedMapboxTiles:(uint64_t)maximumCount;
-
-@end
-
-NS_ASSUME_NONNULL_END
diff --git a/platform/darwin/include/MGLDownloadRegion.h b/platform/darwin/include/MGLOfflineRegion.h
index 5910c2117b..6958e3bffe 100644
--- a/platform/darwin/include/MGLDownloadRegion.h
+++ b/platform/darwin/include/MGLOfflineRegion.h
@@ -4,7 +4,7 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-@protocol MGLDownloadRegion <NSObject>
+@protocol MGLOfflineRegion <NSObject>
 
 @property (nonatomic, readonly) NSURL *styleURL;
 
diff --git a/platform/darwin/include/MGLOfflineStorage.h b/platform/darwin/include/MGLOfflineStorage.h
new file mode 100644
index 0000000000..2d33f3ba69
--- /dev/null
+++ b/platform/darwin/include/MGLOfflineStorage.h
@@ -0,0 +1,30 @@
+#import <Foundation/Foundation.h>
+
+#import "MGLTypes.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class MGLOfflineTask;
+@protocol MGLOfflineRegion;
+
+typedef void (^MGLOfflineTaskRegistrationCompletionHandler)(MGLOfflineTask *task, NSError *error);
+typedef void (^MGLOfflineTaskRemovalCompletionHandler)(NSError *error);
+typedef void (^MGLOfflineTasksRetrievalCompletionHandler)(NS_ARRAY_OF(MGLOfflineTask *) *tasks, NSError *error);
+
+@interface MGLOfflineStorage : NSObject
+
++ (instancetype)sharedOfflineStorage;
+
+- (instancetype)init NS_UNAVAILABLE;
+
+- (void)addTaskForRegion:(id <MGLOfflineRegion>)region withContext:(NSData *)context completionHandler:(MGLOfflineTaskRegistrationCompletionHandler)completion;
+
+- (void)removeTask:(MGLOfflineTask *)task withCompletionHandler:(MGLOfflineTaskRemovalCompletionHandler)completion;
+
+- (void)getTasksWithCompletionHandler:(MGLOfflineTasksRetrievalCompletionHandler)completion;
+
+- (void)setMaximumAllowedMapboxTiles:(uint64_t)maximumCount;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/platform/darwin/include/MGLOfflineTask.h b/platform/darwin/include/MGLOfflineTask.h
new file mode 100644
index 0000000000..72e66a50f5
--- /dev/null
+++ b/platform/darwin/include/MGLOfflineTask.h
@@ -0,0 +1,49 @@
+#import <Foundation/Foundation.h>
+
+#import "MGLOfflineRegion.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol MGLOfflineTaskDelegate;
+
+typedef NS_ENUM (NSInteger, MGLOfflineTaskState) {
+    MGLOfflineTaskStateInactive = 0,
+    MGLOfflineTaskStateActive = 1,
+    MGLOfflineTaskStateComplete = 2,
+};
+
+typedef struct MGLOfflineTaskProgress {
+    uint64_t countOfResourcesCompleted;
+    uint64_t countOfBytesCompleted;
+    uint64_t countOfResourcesExpected;
+    uint64_t maximumResourcesExpected;
+} MGLOfflineTaskProgress;
+
+@interface MGLOfflineTask : NSObject
+
+@property (nonatomic, readonly) id <MGLOfflineRegion> region;
+@property (nonatomic, readonly) NSData *context;
+@property (nonatomic, readonly) MGLOfflineTaskState state;
+@property (nonatomic, readonly) MGLOfflineTaskProgress progress;
+@property (nonatomic, weak, nullable) id <MGLOfflineTaskDelegate> delegate;
+
+- (instancetype)init NS_UNAVAILABLE;
+
+- (void)resume;
+- (void)suspend;
+
+- (void)requestProgress;
+
+@end
+
+@protocol MGLOfflineTaskDelegate <NSObject>
+
+@optional
+
+- (void)offlineTask:(MGLOfflineTask *)task progressDidChange:(MGLOfflineTaskProgress)progress;
+- (void)offlineTask:(MGLOfflineTask *)task didReceiveError:(NSError *)error;
+- (void)offlineTask:(MGLOfflineTask *)task didReceiveMaximumAllowedMapboxTiles:(uint64_t)maximumCount;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/platform/darwin/include/MGLTilePyramidDownloadRegion.h b/platform/darwin/include/MGLTilePyramidOfflineRegion.h
index 6269775f19..7beca3390f 100644
--- a/platform/darwin/include/MGLTilePyramidDownloadRegion.h
+++ b/platform/darwin/include/MGLTilePyramidOfflineRegion.h
@@ -1,11 +1,11 @@
 #import <Foundation/Foundation.h>
 
-#import "MGLDownloadRegion.h"
+#import "MGLOfflineRegion.h"
 #import "MGLGeometry.h"
 
 NS_ASSUME_NONNULL_BEGIN
 
-@interface MGLTilePyramidDownloadRegion : NSObject <MGLDownloadRegion>
+@interface MGLTilePyramidOfflineRegion : NSObject <MGLOfflineRegion>
 
 @property (nonatomic, readonly) MGLCoordinateBounds bounds;
 @property (nonatomic, readonly) double minimumZoomLevel;
diff --git a/platform/darwin/src/MGLDownloadRegion_Private.h b/platform/darwin/src/MGLOfflineRegion_Private.h
index 785775198a..41cd5843f6 100644
--- a/platform/darwin/src/MGLDownloadRegion_Private.h
+++ b/platform/darwin/src/MGLOfflineRegion_Private.h
@@ -1,12 +1,12 @@
 #import <Foundation/Foundation.h>
 
-#import "MGLDownloadRegion.h"
+#import "MGLOfflineRegion.h"
 
 #include <mbgl/storage/offline.hpp>
 
 NS_ASSUME_NONNULL_BEGIN
 
-@protocol MGLDownloadRegion_Private <MGLDownloadRegion>
+@protocol MGLOfflineRegion_Private <MGLOfflineRegion>
 
 - (instancetype)initWithOfflineRegionDefinition:(const mbgl::OfflineRegionDefinition &)definition;
 
diff --git a/platform/darwin/src/MGLDownloadController.mm b/platform/darwin/src/MGLOfflineStorage.mm
index 95eae86b53..17537452a3 100644
--- a/platform/darwin/src/MGLDownloadController.mm
+++ b/platform/darwin/src/MGLOfflineStorage.mm
@@ -1,14 +1,14 @@
-#import "MGLDownloadController_Private.h"
+#import "MGLOfflineStorage_Private.h"
 
 #import "MGLAccountManager_Private.h"
 #import "MGLGeometry_Private.h"
-#import "MGLDownloadable_Private.h"
-#import "MGLDownloadRegion_Private.h"
-#import "MGLTilePyramidDownloadRegion.h"
+#import "MGLOfflineTask_Private.h"
+#import "MGLOfflineRegion_Private.h"
+#import "MGLTilePyramidOfflineRegion.h"
 
 #include <mbgl/util/string.hpp>
 
-@interface MGLDownloadController ()
+@interface MGLOfflineStorage ()
 
 @property (nonatomic) mbgl::DefaultFileSource *mbglFileSource;
 
@@ -16,15 +16,15 @@
 
 @end
 
-@implementation MGLDownloadController
+@implementation MGLOfflineStorage
 
-+ (instancetype)sharedController {
++ (instancetype)sharedOfflineStorage {
     static dispatch_once_t onceToken;
-    static MGLDownloadController *sharedController;
+    static MGLOfflineStorage *sharedOfflineStorage;
     dispatch_once(&onceToken, ^{
-        sharedController = [[self alloc] initWithFileName:@"offline.db"];
+        sharedOfflineStorage = [[self alloc] initWithFileName:@"offline.db"];
     });
-    return sharedController;
+    return sharedOfflineStorage;
 }
 
 - (instancetype)initWithFileName:(NSString *)fileName {
@@ -76,17 +76,17 @@
     }
 }
 
-- (void)addDownloadableForRegion:(id <MGLDownloadRegion>)downloadRegion withContext:(NSData *)context completionHandler:(MGLDownloadableRegistrationCompletionHandler)completion {
-    if (![downloadRegion conformsToProtocol:@protocol(MGLDownloadRegion_Private)]) {
+- (void)addTaskForRegion:(id <MGLOfflineRegion>)region withContext:(NSData *)context completionHandler:(MGLOfflineTaskRegistrationCompletionHandler)completion {
+    if (![region conformsToProtocol:@protocol(MGLOfflineRegion_Private)]) {
         [NSException raise:@"Unsupported region type" format:
-         @"Regions of type %@ are unsupported.", NSStringFromClass([downloadRegion class])];
+         @"Regions of type %@ are unsupported.", NSStringFromClass([region class])];
         return;
     }
     
-    const mbgl::OfflineTilePyramidRegionDefinition regionDefinition = [(id <MGLDownloadRegion_Private>)downloadRegion offlineRegionDefinition];
+    const mbgl::OfflineTilePyramidRegionDefinition regionDefinition = [(id <MGLOfflineRegion_Private>)region offlineRegionDefinition];
     mbgl::OfflineRegionMetadata metadata(context.length);
     [context getBytes:&metadata[0] length:metadata.size()];
-    self.mbglFileSource->createOfflineRegion(regionDefinition, metadata, [&, completion](std::exception_ptr exception, mbgl::optional<mbgl::OfflineRegion> region) {
+    self.mbglFileSource->createOfflineRegion(regionDefinition, metadata, [&, completion](std::exception_ptr exception, mbgl::optional<mbgl::OfflineRegion> mbglOfflineRegion) {
         NSError *error;
         if (exception) {
             NSString *errorDescription = @(mbgl::util::toString(exception).c_str());
@@ -95,16 +95,16 @@
             } : nil];
         }
         if (completion) {
-            MGLDownloadable *downloadable = [[MGLDownloadable alloc] initWithMBGLRegion:new mbgl::OfflineRegion(std::move(*region))];
-            dispatch_async(dispatch_get_main_queue(), [&, completion, error, downloadable](void) {
-                completion(downloadable, error);
+            MGLOfflineTask *task = [[MGLOfflineTask alloc] initWithMBGLRegion:new mbgl::OfflineRegion(std::move(*mbglOfflineRegion))];
+            dispatch_async(dispatch_get_main_queue(), [&, completion, error, task](void) {
+                completion(task, error);
             });
         }
     });
 }
 
-- (void)removeDownloadable:(MGLDownloadable *)downloadable withCompletionHandler:(MGLDownloadableRemovalCompletionHandler)completion {
-    self.mbglFileSource->deleteOfflineRegion(std::move(*downloadable.mbglOfflineRegion), [&, completion](std::exception_ptr exception) {
+- (void)removeTask:(MGLOfflineTask *)task withCompletionHandler:(MGLOfflineTaskRemovalCompletionHandler)completion {
+    self.mbglFileSource->deleteOfflineRegion(std::move(*task.mbglOfflineRegion), [&, completion](std::exception_ptr exception) {
         NSError *error;
         if (exception) {
             error = [NSError errorWithDomain:MGLErrorDomain code:-1 userInfo:@{
@@ -119,7 +119,7 @@
     });
 }
 
-- (void)requestDownloadablesWithCompletionHandler:(MGLDownloadablesRequestCompletionHandler)completion {
+- (void)getTasksWithCompletionHandler:(MGLOfflineTasksRetrievalCompletionHandler)completion {
     self.mbglFileSource->listOfflineRegions([&, completion](std::exception_ptr exception, mbgl::optional<std::vector<mbgl::OfflineRegion>> regions) {
         NSError *error;
         if (exception) {
@@ -127,17 +127,17 @@
                 NSLocalizedDescriptionKey: @(mbgl::util::toString(exception).c_str()),
             }];
         }
-        NSMutableArray *downloadables;
+        NSMutableArray *tasks;
         if (regions) {
-            downloadables = [NSMutableArray arrayWithCapacity:regions->size()];
+            tasks = [NSMutableArray arrayWithCapacity:regions->size()];
             for (mbgl::OfflineRegion &region : *regions) {
-                MGLDownloadable *downloadable = [[MGLDownloadable alloc] initWithMBGLRegion:new mbgl::OfflineRegion(std::move(region))];
-                [downloadables addObject:downloadable];
+                MGLOfflineTask *task = [[MGLOfflineTask alloc] initWithMBGLRegion:new mbgl::OfflineRegion(std::move(region))];
+                [tasks addObject:task];
             }
         }
         if (completion) {
-            dispatch_async(dispatch_get_main_queue(), [&, completion, error, downloadables](void) {
-                completion(downloadables, error);
+            dispatch_async(dispatch_get_main_queue(), [&, completion, error, tasks](void) {
+                completion(tasks, error);
             });
         }
     });
diff --git a/platform/darwin/src/MGLDownloadController_Private.h b/platform/darwin/src/MGLOfflineStorage_Private.h
index 2e26ab90cb..48f87a7785 100644
--- a/platform/darwin/src/MGLDownloadController_Private.h
+++ b/platform/darwin/src/MGLOfflineStorage_Private.h
@@ -1,12 +1,12 @@
-#import "MGLDownloadController.h"
+#import "MGLOfflineStorage.h"
 
-#import "MGLDownloadable.h"
+#import "MGLOfflineTask.h"
 
 #include <mbgl/storage/default_file_source.hpp>
 
 NS_ASSUME_NONNULL_BEGIN
 
-@interface MGLDownloadController (Private)
+@interface MGLOfflineStorage (Private)
 
 @property (nonatomic) mbgl::DefaultFileSource *mbglFileSource;
 
diff --git a/platform/darwin/src/MGLDownloadable.mm b/platform/darwin/src/MGLOfflineTask.mm
index 507461b4b7..a5b6e66031 100644
--- a/platform/darwin/src/MGLDownloadable.mm
+++ b/platform/darwin/src/MGLOfflineTask.mm
@@ -1,40 +1,40 @@
-#import "MGLDownloadable_Private.h"
+#import "MGLOfflineTask_Private.h"
 
-#import "MGLDownloadController_Private.h"
-#import "MGLDownloadRegion_Private.h"
-#import "MGLTilePyramidDownloadRegion.h"
+#import "MGLOfflineStorage_Private.h"
+#import "MGLOfflineRegion_Private.h"
+#import "MGLTilePyramidOfflineRegion.h"
 
 #include <mbgl/storage/default_file_source.hpp>
 #include <mbgl/util/string.hpp>
 
 class MBGLOfflineRegionObserver;
 
-@interface MGLDownloadable ()
+@interface MGLOfflineTask ()
 
 @property (nonatomic, readwrite) mbgl::OfflineRegion *mbglOfflineRegion;
 @property (nonatomic, readwrite) MBGLOfflineRegionObserver *mbglOfflineRegionObserver;
-@property (nonatomic, readwrite) MGLDownloadableState state;
-@property (nonatomic, readwrite) MGLDownloadableProgress progress;
+@property (nonatomic, readwrite) MGLOfflineTaskState state;
+@property (nonatomic, readwrite) MGLOfflineTaskProgress progress;
 
 @end
 
-@implementation MGLDownloadable
+@implementation MGLOfflineTask
 
 - (instancetype)init {
     [NSException raise:@"Method unavailable"
                 format:
-     @"-[MGLDownloadable init] is unavailable. "
-     @"Use +[MGLDownloadController addDownloadRegion:context:completionHandler:] instead."];
+     @"-[MGLOfflineTask init] is unavailable. "
+     @"Use +[MGLOfflineStorage addTaskForRegion:withContext:completionHandler:] instead."];
     return nil;
 }
 
 - (instancetype)initWithMBGLRegion:(mbgl::OfflineRegion *)region {
     if (self = [super init]) {
         _mbglOfflineRegion = region;
-        _state = MGLDownloadableStateInactive;
+        _state = MGLOfflineTaskStateInactive;
         _mbglOfflineRegionObserver = new MBGLOfflineRegionObserver(self);
         
-        mbgl::DefaultFileSource *mbglFileSource = [[MGLDownloadController sharedController] mbglFileSource];
+        mbgl::DefaultFileSource *mbglFileSource = [[MGLOfflineStorage sharedOfflineStorage] mbglFileSource];
         mbglFileSource->setOfflineRegionObserver(*_mbglOfflineRegion, std::make_unique<MBGLOfflineRegionObserver>(*_mbglOfflineRegionObserver));
     }
     return self;
@@ -45,10 +45,10 @@ class MBGLOfflineRegionObserver;
     _mbglOfflineRegionObserver = nullptr;
 }
 
-- (id <MGLDownloadRegion>)region {
+- (id <MGLOfflineRegion>)region {
     const mbgl::OfflineRegionDefinition &regionDefinition = _mbglOfflineRegion->getDefinition();
-    NSAssert([MGLTilePyramidDownloadRegion conformsToProtocol:@protocol(MGLDownloadRegion_Private)], @"MGLTilePyramidDownloadRegion should conform to MGLDownloadRegion_Private.");
-    return [(id <MGLDownloadRegion_Private>)[MGLTilePyramidDownloadRegion alloc] initWithOfflineRegionDefinition:regionDefinition];
+    NSAssert([MGLTilePyramidOfflineRegion conformsToProtocol:@protocol(MGLOfflineRegion_Private)], @"MGLTilePyramidOfflineRegion should conform to MGLOfflineRegion_Private.");
+    return [(id <MGLOfflineRegion_Private>)[MGLTilePyramidOfflineRegion alloc] initWithOfflineRegionDefinition:regionDefinition];
 }
 
 - (NSData *)context {
@@ -57,26 +57,26 @@ class MBGLOfflineRegionObserver;
 }
 
 - (void)resume {
-    mbgl::DefaultFileSource *mbglFileSource = [[MGLDownloadController sharedController] mbglFileSource];
+    mbgl::DefaultFileSource *mbglFileSource = [[MGLOfflineStorage sharedOfflineStorage] mbglFileSource];
     mbglFileSource->setOfflineRegionDownloadState(*_mbglOfflineRegion, mbgl::OfflineRegionDownloadState::Active);
-    self.state = MGLDownloadableStateActive;
+    self.state = MGLOfflineTaskStateActive;
 }
 
 - (void)suspend {
-    mbgl::DefaultFileSource *mbglFileSource = [[MGLDownloadController sharedController] mbglFileSource];
+    mbgl::DefaultFileSource *mbglFileSource = [[MGLOfflineStorage sharedOfflineStorage] mbglFileSource];
     mbglFileSource->setOfflineRegionDownloadState(*_mbglOfflineRegion, mbgl::OfflineRegionDownloadState::Inactive);
-    self.state = MGLDownloadableStateInactive;
+    self.state = MGLOfflineTaskStateInactive;
 }
 
 - (void)requestProgress {
-    mbgl::DefaultFileSource *mbglFileSource = [[MGLDownloadController sharedController] mbglFileSource];
+    mbgl::DefaultFileSource *mbglFileSource = [[MGLOfflineStorage sharedOfflineStorage] mbglFileSource];
     
-    __weak MGLDownloadable *weakSelf = self;
+    __weak MGLOfflineTask *weakSelf = self;
     mbglFileSource->getOfflineRegionStatus(*_mbglOfflineRegion, [&, weakSelf](__unused std::exception_ptr exception, mbgl::optional<mbgl::OfflineRegionStatus> status) {
         if (status) {
             mbgl::OfflineRegionStatus checkedStatus = *status;
             dispatch_async(dispatch_get_main_queue(), ^{
-                MGLDownloadable *strongSelf = weakSelf;
+                MGLOfflineTask *strongSelf = weakSelf;
                 [strongSelf offlineRegionStatusDidChange:checkedStatus];
             });
         }
@@ -86,23 +86,23 @@ class MBGLOfflineRegionObserver;
 - (void)offlineRegionStatusDidChange:(mbgl::OfflineRegionStatus)status {
     switch (status.downloadState) {
         case mbgl::OfflineRegionDownloadState::Inactive:
-            self.state = status.complete() ? MGLDownloadableStateComplete : MGLDownloadableStateInactive;
+            self.state = status.complete() ? MGLOfflineTaskStateComplete : MGLOfflineTaskStateInactive;
             break;
             
         case mbgl::OfflineRegionDownloadState::Active:
-            self.state = MGLDownloadableStateActive;
+            self.state = MGLOfflineTaskStateActive;
             break;
     }
     
-    MGLDownloadableProgress progress;
+    MGLOfflineTaskProgress progress;
     progress.countOfResourcesCompleted = status.completedResourceCount;
     progress.countOfBytesCompleted = status.completedResourceSize;
     progress.countOfResourcesExpected = status.requiredResourceCount;
     progress.maximumResourcesExpected = status.requiredResourceCountIsPrecise ? status.requiredResourceCount : UINT64_MAX;
     self.progress = progress;
     
-    if ([self.delegate respondsToSelector:@selector(downloadable:progressDidChange:)]) {
-        [self.delegate downloadable:self progressDidChange:progress];
+    if ([self.delegate respondsToSelector:@selector(offlineTask:progressDidChange:)]) {
+        [self.delegate offlineTask:self progressDidChange:progress];
     }
 }
 
@@ -131,28 +131,28 @@ NSError *MGLErrorFromResponseError(mbgl::Response::Error error) {
 
 void MBGLOfflineRegionObserver::statusChanged(mbgl::OfflineRegionStatus status) {
     dispatch_async(dispatch_get_main_queue(), ^{
-        NSCAssert(downloadable, @"MBGLOfflineRegionObserver is dangling without an associated MGLDownloadable.");
+        NSCAssert(offlineTask, @"MBGLOfflineRegionObserver is dangling without an associated MGLOfflineTask.");
         
-        [downloadable offlineRegionStatusDidChange:status];
+        [offlineTask offlineRegionStatusDidChange:status];
     });
 }
 
 void MBGLOfflineRegionObserver::responseError(mbgl::Response::Error error) {
     dispatch_async(dispatch_get_main_queue(), ^{
-        NSCAssert(downloadable, @"MBGLOfflineRegionObserver is dangling without an associated MGLDownloadable.");
+        NSCAssert(offlineTask, @"MBGLOfflineRegionObserver is dangling without an associated MGLOfflineTask.");
         
-        if ([downloadable.delegate respondsToSelector:@selector(downloadable:didReceiveError:)]) {
-            [downloadable.delegate downloadable:downloadable didReceiveError:MGLErrorFromResponseError(error)];
+        if ([offlineTask.delegate respondsToSelector:@selector(offlineTask:didReceiveError:)]) {
+            [offlineTask.delegate offlineTask:offlineTask didReceiveError:MGLErrorFromResponseError(error)];
         }
     });
 }
 
 void MBGLOfflineRegionObserver::mapboxTileCountLimitExceeded(uint64_t limit) {
     dispatch_async(dispatch_get_main_queue(), ^{
-        NSCAssert(downloadable, @"MBGLOfflineRegionObserver is dangling without an associated MGLDownloadable.");
+        NSCAssert(offlineTask, @"MBGLOfflineRegionObserver is dangling without an associated MGLOfflineTask.");
         
-        if ([downloadable.delegate respondsToSelector:@selector(downloadable:didReceiveMaximumAllowedMapboxTiles:)]) {
-            [downloadable.delegate downloadable:downloadable didReceiveMaximumAllowedMapboxTiles:limit];
+        if ([offlineTask.delegate respondsToSelector:@selector(offlineTask:didReceiveMaximumAllowedMapboxTiles:)]) {
+            [offlineTask.delegate offlineTask:offlineTask didReceiveMaximumAllowedMapboxTiles:limit];
         }
     });
 }
diff --git a/platform/darwin/src/MGLDownloadable_Private.h b/platform/darwin/src/MGLOfflineTask_Private.h
index a9b2460c19..ad0e597a8d 100644
--- a/platform/darwin/src/MGLDownloadable_Private.h
+++ b/platform/darwin/src/MGLOfflineTask_Private.h
@@ -1,10 +1,10 @@
-#import "MGLDownloadable.h"
+#import "MGLOfflineTask.h"
 
 #include <mbgl/storage/default_file_source.hpp>
 
 class MBGLOfflineRegionObserver;
 
-@interface MGLDownloadable (Private)
+@interface MGLOfflineTask (Private)
 
 @property (nonatomic) mbgl::OfflineRegion *mbglOfflineRegion;
 @property (nonatomic, readonly) MBGLOfflineRegionObserver *mbglOfflineRegionObserver;
@@ -15,12 +15,12 @@ class MBGLOfflineRegionObserver;
 
 class MBGLOfflineRegionObserver : public mbgl::OfflineRegionObserver {
 public:
-    MBGLOfflineRegionObserver(MGLDownloadable *downloadable_) : downloadable(downloadable_) {}
+    MBGLOfflineRegionObserver(MGLOfflineTask *offlineTask_) : offlineTask(offlineTask_) {}
     
     void statusChanged(mbgl::OfflineRegionStatus status) override;
     void responseError(mbgl::Response::Error error) override;
     void mapboxTileCountLimitExceeded(uint64_t limit) override;
     
 private:
-    __weak MGLDownloadable *downloadable = nullptr;
+    __weak MGLOfflineTask *offlineTask = nullptr;
 };
diff --git a/platform/darwin/src/MGLTilePyramidDownloadRegion.mm b/platform/darwin/src/MGLTilePyramidOfflineRegion.mm
index 94c0ac6358..3d51917c3e 100644
--- a/platform/darwin/src/MGLTilePyramidDownloadRegion.mm
+++ b/platform/darwin/src/MGLTilePyramidOfflineRegion.mm
@@ -1,18 +1,18 @@
-#import "MGLTilePyramidDownloadRegion.h"
+#import "MGLTilePyramidOfflineRegion.h"
 
 #if !TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR
     #import <Cocoa/Cocoa.h>
 #endif
 
-#import "MGLDownloadRegion_Private.h"
+#import "MGLOfflineRegion_Private.h"
 #import "MGLGeometry_Private.h"
 #import "MGLStyle.h"
 
-@interface MGLTilePyramidDownloadRegion () <MGLDownloadRegion_Private>
+@interface MGLTilePyramidOfflineRegion () <MGLOfflineRegion_Private>
 
 @end
 
-@implementation MGLTilePyramidDownloadRegion {
+@implementation MGLTilePyramidOfflineRegion {
     NSURL *_styleURL;
 }
 
@@ -21,7 +21,7 @@
 - (instancetype)init {
     [NSException raise:@"Method unavailable"
                 format:
-     @"-[MGLTilePyramidDownloadRegion init] is unavailable. "
+     @"-[MGLTilePyramidOfflineRegion init] is unavailable. "
      @"Use -initWithStyleURL:bounds:fromZoomLevel:toZoomLevel: instead."];
     return nil;
 }