As the Calendar is linked to Google, I would completely remove it from Lightning and add it again.

Matt said

As the Calendar is linked to Google, I would completely remove it from Lightning and add it again.

Unfortunately Matt, this didn't work. Troubleshooting Info says I have Lightning 4.7, but I still have the problem.

Also, are you aware that there are many complaints at AddOns since T'bird 45 was installed because Lightning has not upgraded? Lots of upset people.

Also, I realized just now that the Provider for Google Calendar might be at fault since the last upgrade for it was in January.

I disabled Provider for Google Calendar and the popup stopped as well as the syncing to Gmail and my phone's Gmail. Not sure if this means that Provider is the problem or?

I am attaching an image of the Error in Error Console and only part of what that error reads because of the limits of this editor. Will post another reply with the rest of the message

               cal.ERROR("[calGoogleCalendar] Deleting item " + aItem.title +
                         " failed:" + code + ": " + e.message);
           }
           this.notifyPureOperationComplete(aListener, code, cIOL.DELETE, aItem.id, e.message);
       }.bind(this));
       return request;
   },

   getItem: function(aId, aListener) {
       this.mOfflineStorage.getItem.apply(this.mOfflineStorage, arguments);
   },

   getItems: function(aFilter, aCount, aRangeStart, aRangeEnd, aListener) {
       this.mOfflineStorage.getItems.apply(this.mOfflineStorage, arguments);
   },

   refresh: function() {
       this.mObservers.notify("onLoad", [this]);
   },

   migrateStorageCache: function() {
       let cacheVersion = this.getProperty("cache.version");
       if (!cacheVersion || cacheVersion >= this.CACHE_DB_VERSION) {
           // Either up to date or first run, make sure property set right.
           this.setProperty("cache.version", this.CACHE_DB_VERSION);
           return Promise.resolve(false);
       }

       let needsReset = false;
       cal.LOG("[calGoogleCalendar] Migrating cache from " +
               cacheVersion + " to " + this.CACHE_DB_VERSION + " for " + this.name);

       if (cacheVersion < 2) {
           // The initial version 1.0 had some issues that required resetting
           // the cache.
           needsReset = true;
       }

       if (cacheVersion < 3) {
           // There was an issue with ids from the birthday calendar, we need
           // to reset just this calendar. See bug 1169062.
           let birthdayCalendar = "#contacts@group.v.calendar.google.com";
           if (this.mCalendarName && this.mCalendarName == birthdayCalendar) {
               needsReset = true;
           }
       }

       // Migration all done. Reset if requested.
       if (needsReset) {
           return this.resetSync().then(function() {
               this.setProperty("cache.version", this.CACHE_DB_VERSION);
               return needsReset;
           }.bind(this));
       } else {
           this.setProperty("cache.version", this.CACHE_DB_VERSION);
           return Promise.resolve(needsReset);
       }
   },

   /**
    * Implement calIChangeLog
    */
   get offlineStorage() { return this.mOfflineStorage; },
   set offlineStorage(val) {
       this.mOfflineStorage = val;
       this.migrateStorageCache();
       return val;
   },

   resetLog: function() {
       this.resetSync().then(function() {
           this.mObservers.notify("onLoad", [this]);
       }.bind(this));
   },

   resetSync: function() {
       let deferred = PromiseUtils.defer();
       cal.LOG("[calGoogleCalendar] Resetting last updated counter for " + this.name);
       this.setProperty("syncToken.events", "");
       this.setProperty("lastUpdated.tasks", "");
       this.mThrottle = Object.create(null);
       this.mOfflineStorage.QueryInterface(Components.interfaces.calICalendarProvider)
                           .deleteCalendar(this.mOfflineStorage, {
           onDeleteCalendar: function(aCalendar, aStatus, aDetail) {
               if (Components.isSuccessCode(aStatus)) {
                   deferred.resolve();
               } else {
                   deferred.reject(aDetail);
               }
           }
      });
      return deferred.promise;
   },

   replayChangesOn: function(aListener) {
       // Figure out if the user is idle, no need to synchronize if so.
       let idleTime = Components.classes["@mozilla.org/widget/idleservice;1"]
                                .getService(Components.interfaces.nsIIdleService)
                                .idleTime;
       let maxIdleTime = Preferences.get("calendar.google.idleTime", 300) * 1000;

       if (maxIdleTime != 0 && idleTime > maxIdleTime) {
           cal.LOG("[calGoogleCalendar] Skipping refresh since user is idle");
           aListener.onResult({ status: Components.results.NS_OK }, null);
           return Promise.resolve();
       }

       // Now that we've determined we are not idle we can continue with the sync.
       let maxResults = Preferences.get("calendar.google.maxResultsPerRequest", null);

       // We are going to be making potentially lots of changes to the offline
       // storage, start a batch operation.
       this.mOfflineStorage.startBatch();

       // Update the calendar settings
       let calendarPromise = Promise.resolve();
       if (this.mCalendarName && this.checkThrottle("calendarList")) {
           let calendarRequest = new calGoogleRequest();
           calendarRequest.calendar = this;
           calendarRequest.type = calendarRequest.GET;
           calendarRequest.uri = this.createUsersURI("calendarList", this.mCalendarName)
           calendarPromise = this.session.asyncItemRequest(calendarRequest).then(function(aData) {
               if (aData.defaultReminders) {
                   this.defaultReminders = aData.defaultReminders.map(function(x) { return JSONToAlarm(x, true); });
               } else {
                   this.defaultReminders = [];
               }

               for each (let k in ["accessRole", "backgroundColor", "description",
                                   "foregroundColor", "location", "primary",
                                   "summary", "summaryOverride", "timeZone"]) {
                   this.setProperty("settings." + k, aData[k]);
               }
               this.setProperty("settings.defaultReminders", JSON.stringify(aData.defaultReminders));
           }.bind(this));
       }

       // Set up a request for the events
       let eventsRequest = new calGoogleRequest();
       let eventsPromise = Promise.resolve();
       eventsRequest.calendar = this;
       eventsRequest.type = eventsRequest.GET;
       eventsRequest.uri = this.createEventsURI("events");
       eventsRequest.addQueryParameter("maxResults", maxResults);
       let syncToken = this.getProperty("syncToken.events");
       if (syncToken) {
           eventsRequest.addQueryParameter("showDeleted", "true");
           eventsRequest.addQueryParameter("syncToken", syncToken);
       }
       if (eventsRequest.uri && this.checkThrottle("events")) {
           let saver = new ItemSaver(this);
           eventsPromise = this.session.asyncPaginatedRequest(eventsRequest, null, function(aData) {
               // On each request...
               return saver.parseItemStream(aData);
           }.bind(this), function(aData) {
               // On last request...
               return saver.complete().then(function() {
                   if (aData.nextSyncToken) {
                       cal.LOG("[calGoogleCalendar] New sync token for " +
                               this.name + "(events) is now: " + aData.nextSyncToken);
                       this.setProperty("syncToken.events", aData.nextSyncToken);
                   }
               }.bind(this));
           }.bind(this));
       }

       // Set up a request for tasks
       let tasksRequest = new calGoogleRequest();
       let tasksPromise = Promise.resolve();
       tasksRequest.calendar = this;
       tasksRequest.type = tasksRequest.GET;
       tasksRequest.uri = this.createTasksURI("tasks");
       tasksRequest.addQueryParameter("maxResults", maxResults);
       let lastUpdated = this.getUpdatedMin("tasks");
       if (lastUpdated) {
           tasksRequest.addQueryParameter("updatedMin", cal.toRFC3339(lastUpdated));
           tasksRequest.addQueryParameter("showDeleted", "true");
       }
       if (tasksRequest.uri && this.checkThrottle("tasks")) {
           let saver = new ItemSaver(this);
           let lastUpdated = null;
           tasksPromise = this.session.asyncPaginatedRequest(tasksRequest, function(aData) {
               // On the first request...
               lastUpdated = tasksRequest.requestDate.icalString;
           }.bind(this), function(aData) {
               // On each request...
               return saver.parseItemStream(aData);
           }.bind(this), function(aData) {
               // On last request...
               return saver.complete().then(function() {
                   cal.LOG("[calGoogleCalendar] Last sync date for " + this.name +
                           "(tasks) is now: " + tasksRequest.requestDate.toString());
                   this.setProperty("lastUpdated.tasks", lastUpdated);
               }.bind(this));
           }.bind(this));
       }

return PromiseAll([calendarPromise, eventsPromise, tasksPromise]).then(function() {

           this.mOfflineStorage.endBatch();
           aListener.onResult({ status: Components.results.NS_OK }, null);
       }.bind(this), function(e) {
           this.mOfflineStorage.endBatch();
           let code = e.result || Components.results.NS_ERROR_FAILURE;
           if (code == calGoogleRequest.RESOURCE_GONE) {
               cal.LOG("[calGoogleCalendar] Server did not accept " +
                       "incremental update, resetting calendar and " +
                       "starting over.");
               this.resetSync().then(function() {
                   this.replayChangesOn(aListener);
               }.bind(this), function(e) {
                   cal.ERROR("[calGoogleCalendar] Error resetting calendar:\n" +
                           stringException(e));
                   aListener.onResult({ status: e.result }, e.message);
               }.bind(this));
           } else {
               cal.LOG("[calGoogleCalendar] Error syncing:\n" + code + ":" +
                       stringException(e));
               aListener.onResult({ status: code }, e.message);
           }
       }.bind(this));
   },

   /**
    * Implement calISchedulingSupport. Most is taken care of by the base
    * provider, but we want to advertise that we will always take care of
    * notifications.
    */
   canNotify: function(aMethod, aItem) { return true; }

};

var NSGetFactory = XPCOMUtils.generateNSGetFactory([calGoogleCalendar]);