Move GeolocationDispatcher into blink.

third_party/WebKit/Source/modules/geolocation/Geolocation.cpp

 /*
  * Copyright (C) 2008, 2009, 2010, 2011 Apple Inc. All Rights Reserved.
  * Copyright (C) 2009 Torch Mobile, Inc.
  * Copyright 2010, The Android Open Source Project
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 75 matching lines @@
 Geolocation* Geolocation::create(ExecutionContext* context)
 {
     Geolocation* geolocation = new Geolocation(context);
     geolocation->suspendIfNeeded();
     return geolocation;
 }
 
 Geolocation::Geolocation(ExecutionContext* context)
     : ActiveDOMObject(context)
     , m_geolocationPermission(PermissionUnknown)
+    , m_controller(new GeolocationController(this))

[Marijn Kruisselbrink, 2015/09/30 19:56:55]

Unless I'm missing something, the change to lifetime/ownership of
GeolocationController is completely unrelated to the changes in this CL?
It might definitely make sense to make such a change (and I think it might even
be mostly equivalent), but mixing the two refactors in one CL makes it a bit
hard to see which changes are for what reason.

I can think of a few reasons why you might have ended up mixing these two up,
but they're all for changes in behavior that should probably be separate CLs as
well.

Also this seems like it could be the cause of the layout tests you deleted no
longer passing?

[Sam McNally, 2015/10/01 01:54:50]

For a real CL it's worth splitting this up, but I think it's useful here for
examining how much simplification switching to mojo allows.
That test assumed all subframes shared a GeolocationClient with the parent
frame, which was only true due to the test setup.

[Marijn Kruisselbrink, 2015/10/01 03:36:09]

But changing the ownership and lifetime management for GeolocationController has
nothing whatsoever to do with switching to mojo. Both changes are completely
independent and by having them both in the CL it just becomes harder to see what
simplification switching to mojo allows.
Yes, and there is no reason to mix up changing that test setup with this CL. If
you keep GeolocationController to be tied to the Frame, you can keep using the
exact same test setup. No need to mix changing that part of the design and that
part of the test setup with the rest of this CL.

[Sam McNally, 2015/10/02 05:12:37]

Changing ownership of GeolocationController depends on switching to using mojo.
In fact, switching to mojo enables removing GeolocationController (and
GeolocationPosition) entirely.
The test change is independent of the change to GeolocationController ownership.
That test relied on the GeolocationClientMock being shared by
GeolocationControllers from different frames and being able to return cached
results synchronously. With the removal of GeolocationClient, this is no longer
possible.

 {
 }
 
 Geolocation::~Geolocation()
 {
     ASSERT(m_geolocationPermission != PermissionRequested);
 }
 
 DEFINE_TRACE(Geolocation)
 {
     visitor->trace(m_oneShots);
     visitor->trace(m_watchers);
     visitor->trace(m_pendingForPermissionNotifiers);
     visitor->trace(m_lastPosition);
     visitor->trace(m_requestsAwaitingCachedPosition);
+    visitor->trace(m_controller);
     ActiveDOMObject::trace(visitor);
 }
 
 Document* Geolocation::document() const
 {
     return toDocument(executionContext());
 }
 
 LocalFrame* Geolocation::frame() const
 {
     return document() ? document()->frame() : 0;
 }
 
 void Geolocation::stop()
 {
     LocalFrame* frame = this->frame();
     if (frame && m_geolocationPermission == PermissionRequested)
-        GeolocationController::from(frame)->cancelPermissionRequest(this);
+        m_controller->cancelPermissionRequest();
 
     // The frame may be moving to a new page and we want to get the permissions from the new page's client.
     m_geolocationPermission = PermissionUnknown;
     cancelAllRequests();
     stopUpdating();
     m_pendingForPermissionNotifiers.clear();
 }
 
 Geoposition* Geolocation::lastPosition()
 {
-    LocalFrame* frame = this->frame();
-    if (!frame)
-        return 0;
-
-    m_lastPosition = createGeoposition(GeolocationController::from(frame)->lastPosition());
+    m_lastPosition = createGeoposition(m_controller->lastPosition());
 
     return m_lastPosition.get();
 }
 
 void Geolocation::recordOriginTypeAccess() const
 {
     ASSERT(frame());
 
     Document* document = this->document();
     ASSERT(document);
@@ skipping 306 matching lines @@
 
     // Maintain a reference to the cached notifiers until their timer fires.
     copyToSet(oneShotsWithCachedPosition, m_oneShots);
 }
 
 void Geolocation::requestPermission()
 {
     if (m_geolocationPermission != PermissionUnknown)
         return;
 
-    LocalFrame* frame = this->frame();
-    if (!frame)
-        return;
-
     m_geolocationPermission = PermissionRequested;
 
     // Ask the embedder: it maintains the geolocation challenge policy itself.
-    GeolocationController::from(frame)->requestPermission(this);
+    m_controller->requestPermission();
 }
 
 void Geolocation::makeSuccessCallbacks()
 {
     ASSERT(lastPosition());
     ASSERT(isAllowed());
 
     GeoNotifierVector oneShotsCopy;
     copyToVector(m_oneShots, oneShotsCopy);
 
@@ skipping 27 matching lines @@
     makeSuccessCallbacks();
 }
 
 void Geolocation::setError(GeolocationError* error)
 {
     handleError(createPositionError(error));
 }
 
 bool Geolocation::startUpdating(GeoNotifier* notifier)
 {
-    LocalFrame* frame = this->frame();
-    if (!frame)
-        return false;
-
-    GeolocationController::from(frame)->addObserver(this, notifier->options().enableHighAccuracy());
+    m_controller->startUpdating(notifier->options().enableHighAccuracy());
     return true;
 }
 
 void Geolocation::stopUpdating()
 {
-    LocalFrame* frame = this->frame();
-    if (!frame)
-        return;
-
-    GeolocationController::from(frame)->removeObserver(this);
+    m_controller->stopUpdating();
 }
 
 void Geolocation::handlePendingPermissionNotifiers()
 {
     // While we iterate through the list, we need not worry about list being modified as the permission
     // is already set to Yes/No and no new listeners will be added to the pending list.
     for (GeoNotifier* notifier : m_pendingForPermissionNotifiers) {
         if (isAllowed()) {
             // start all pending notification requests as permission granted.
             // The notifier is always ref'ed by m_oneShots or m_watchers.
             if (startUpdating(notifier))
                 notifier->startTimer();
             else
                 notifier->setFatalError(PositionError::create(PositionError::POSITION_UNAVAILABLE, failedToStartServiceErrorMessage));
         } else {
             notifier->setFatalError(PositionError::create(PositionError::PERMISSION_DENIED, permissionDeniedErrorMessage));
         }
     }
 }
 
 } // namespace blink